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
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 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
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 442 #include <dali/devel-api/adaptor-framework/image-loading.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 472 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
 473
 474 // add here SWIG version check
 475
 476 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 477 // disable Swig-dependent warnings
 478
 479 // 'identifier1' has C-linkage specified,
 480 // but returns UDT 'identifier2' which is incompatible with C
 481 #pragma warning(disable: 4190)
 482
 483 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 484 #pragma warning(disable: 4800)
 485
 486 // debug info too long etc etc
 487 #pragma warning(disable: 4786)
 488 #endif
 489
 490
 491 #include <stdexcept>
 492
 493
 494 #include <string>
 495
 496
 497 #include <vector>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <map>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <utility>
 508
 509
 510 typedef float floatp;
 511
 512 SWIGINTERN floatp *new_floatp(){
 513   return new float();
 514 }
 515 SWIGINTERN void delete_floatp(floatp *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void floatp_assign(floatp *self,float value){
 519   *self = value;
 520 }
 521 SWIGINTERN float floatp_value(floatp *self){
 522   return *self;
 523 }
 524 SWIGINTERN float *floatp_cast(floatp *self){
 525   return self;
 526 }
 527 SWIGINTERN floatp *floatp_frompointer(float *t){
 528   return (floatp *) t;
 529 }
 530
 531 typedef int intp;
 532
 533 SWIGINTERN intp *new_intp(){
 534   return new int();
 535 }
 536 SWIGINTERN void delete_intp(intp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void intp_assign(intp *self,int value){
 540   *self = value;
 541 }
 542 SWIGINTERN int intp_value(intp *self){
 543   return *self;
 544 }
 545 SWIGINTERN int *intp_cast(intp *self){
 546   return self;
 547 }
 548 SWIGINTERN intp *intp_frompointer(int *t){
 549   return (intp *) t;
 550 }
 551
 552 typedef double doublep;
 553
 554 SWIGINTERN doublep *new_doublep(){
 555   return new double();
 556 }
 557 SWIGINTERN void delete_doublep(doublep *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void doublep_assign(doublep *self,double value){
 561   *self = value;
 562 }
 563 SWIGINTERN double doublep_value(doublep *self){
 564   return *self;
 565 }
 566 SWIGINTERN double *doublep_cast(doublep *self){
 567   return self;
 568 }
 569 SWIGINTERN doublep *doublep_frompointer(double *t){
 570   return (doublep *) t;
 571 }
 572
 573 typedef unsigned int uintp;
 574
 575 SWIGINTERN uintp *new_uintp(){
 576   return new unsigned int();
 577 }
 578 SWIGINTERN void delete_uintp(uintp *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 582   *self = value;
 583 }
 584 SWIGINTERN unsigned int uintp_value(uintp *self){
 585   return *self;
 586 }
 587 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 588   return self;
 589 }
 590 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 591   return (uintp *) t;
 592 }
 593
 594 typedef unsigned short ushortp;
 595
 596 SWIGINTERN ushortp *new_ushortp(){
 597   return new unsigned short();
 598 }
 599 SWIGINTERN void delete_ushortp(ushortp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 609   return self;
 610 }
 611 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 612   return (ushortp *) t;
 613 }
 614
 615 unsigned int int_to_uint(int x) {
 616    return (unsigned int) x;
 617 }
 618
 619
 620 using namespace Dali;
 621 using namespace Dali::Toolkit;
 622
 623 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 624 {
 625   bool result = false;
 626   try
 627   {
 628     // C++ code. DALi uses Handle <-> Body design pattern.
 629     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 630     // Handles in DALi can be converted into a boolean type
 631     // to check if the handle has a valid body attached to it.
 632     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 633     if( *self )
 634     {
 635       result = true;
 636     }
 637     else
 638     {
 639       result = false;
 640     }
 641   }
 642   catch (std::out_of_range& e)
 643   {
 644     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 645     return 0;
 646   }
 647   catch (std::exception& e)
 648   {
 649     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (DaliException e)
 653   {
 654     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 655     return 0;
 656   }
 657   catch (...)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 660     return 0;
 661   }
 662   return result;
 663 }
 664
 665 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 666 {
 667   bool result = false;
 668   try
 669   {
 670     // C++ code. Check if two handles reference the same implemtion
 671     if( *self == rhs)
 672     {
 673       result = true;
 674     }
 675     else
 676     {
 677       result = false;
 678     }
 679   }
 680   catch (std::out_of_range& e)
 681   {
 682     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 683     return 0;
 684   }
 685   catch (std::exception& e)
 686   {
 687     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (DaliException e)
 691   {
 692     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 693     return 0;
 694   }
 695   catch (...)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 698     return 0;
 699   }
 700   return result;
 701 }
 702
 703
 704 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 705      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 706    }
 707 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){
 708      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 709    }
 710 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 711         std::vector< Dali::TouchPoint >* pv = 0;
 712         if (capacity >= 0) {
 713           pv = new std::vector< Dali::TouchPoint >();
 714           pv->reserve(capacity);
 715        } else {
 716           throw std::out_of_range("capacity");
 717        }
 718        return pv;
 719       }
 720 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 721         if (index>=0 && index<(int)self->size())
 722           return (*self)[index];
 723         else
 724           throw std::out_of_range("index");
 725       }
 726 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 727         if (index>=0 && index<(int)self->size())
 728           return (*self)[index];
 729         else
 730           throw std::out_of_range("index");
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 733         if (index>=0 && index<(int)self->size())
 734           (*self)[index] = val;
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 739         self->insert(self->end(), values.begin(), values.end());
 740       }
 741 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (count < 0)
 745           throw std::out_of_range("count");
 746         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 747           throw std::invalid_argument("invalid range");
 748         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 749       }
 750 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 751         if (index>=0 && index<(int)self->size()+1)
 752           self->insert(self->begin()+index, x);
 753         else
 754           throw std::out_of_range("index");
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 757         if (index>=0 && index<(int)self->size()+1)
 758           self->insert(self->begin()+index, values.begin(), values.end());
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 763         if (index>=0 && index<(int)self->size())
 764           self->erase(self->begin() + index);
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 769         if (index < 0)
 770           throw std::out_of_range("index");
 771         if (count < 0)
 772           throw std::out_of_range("count");
 773         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 774           throw std::invalid_argument("invalid range");
 775         self->erase(self->begin()+index, self->begin()+index+count);
 776       }
 777 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         return new std::vector< Dali::TouchPoint >(count, value);
 781       }
 782 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 783         std::reverse(self->begin(), self->end());
 784       }
 785 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 786         if (index < 0)
 787           throw std::out_of_range("index");
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 791           throw std::invalid_argument("invalid range");
 792         std::reverse(self->begin()+index, self->begin()+index+count);
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 795         if (index < 0)
 796           throw std::out_of_range("index");
 797         if (index+values.size() > self->size())
 798           throw std::out_of_range("index");
 799         std::copy(values.begin(), values.end(), self->begin()+index);
 800       }
 801 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 802          return self->Empty();
 803       }
 804 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 805         return self->GetConnectionCount();
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 808           self->Connect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 811           self->Disconnect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 814           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 815 /*@SWIG@*/ self->Emit( arg );
 816       }
 817 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 818          return self->Empty();
 819       }
 820 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 821         return self->GetConnectionCount();
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 824           self->Connect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 827           self->Disconnect( func );
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 830           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 831 /*@SWIG@*/ self->Emit( arg );
 832       }
 833 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 834          return self->Empty();
 835       }
 836 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){
 837         return self->GetConnectionCount();
 838       }
 839 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 *)){
 840           self->Connect( func );
 841       }
 842 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 *)){
 843           self->Disconnect( func );
 844       }
 845 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){
 846           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 847 /*@SWIG@*/ self->Emit( arg );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 856           self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 859           self->Disconnect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 866          return self->Empty();
 867       }
 868 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 869         return self->GetConnectionCount();
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 872           self->Connect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 875           self->Disconnect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 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){
 882          return self->Empty();
 883       }
 884 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){
 885         return self->GetConnectionCount();
 886       }
 887 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 &)){
 888         self->Connect( func );
 889       }
 890 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 &)){
 891         self->Disconnect( func );
 892       }
 893 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){
 894         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg1, arg2 );
 896       }
 897 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){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904         self->Connect( func );
 905       }
 906 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 &)){
 907         self->Disconnect( func );
 908       }
 909 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){
 910         return self->Emit( arg1, arg2 );
 911       }
 912 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){
 913          return self->Empty();
 914       }
 915 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){
 916         return self->GetConnectionCount();
 917       }
 918 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 &)){
 919         self->Connect( func );
 920       }
 921 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 &)){
 922         self->Disconnect( func );
 923       }
 924 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){
 925         return self->Emit( arg1, arg2 );
 926       }
 927 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){
 928          return self->Empty();
 929       }
 930 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){
 931         return self->GetConnectionCount();
 932       }
 933 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 &)){
 934         self->Connect( func );
 935       }
 936 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 &)){
 937         self->Disconnect( func );
 938       }
 939 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){
 940         return self->Emit( arg1, arg2 );
 941       }
 942 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 943          return self->Empty();
 944       }
 945 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 946         return self->GetConnectionCount();
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 949           self->Connect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 952           self->Disconnect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 955           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 956 /*@SWIG@*/ self->Emit( arg );
 957       }
 958 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 959          return self->Empty();
 960       }
 961 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){
 962         return self->GetConnectionCount();
 963       }
 964 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 &)){
 965           self->Connect( func );
 966       }
 967 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 &)){
 968           self->Disconnect( func );
 969       }
 970 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){
 971           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 972 /*@SWIG@*/ self->Emit( arg );
 973       }
 974 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 975          return self->Empty();
 976       }
 977 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){
 978         return self->GetConnectionCount();
 979       }
 980 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 &)){
 981           self->Connect( func );
 982       }
 983 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 &)){
 984           self->Disconnect( func );
 985       }
 986 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){
 987           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 988 /*@SWIG@*/ self->Emit( arg );
 989       }
 990 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 991          return self->Empty();
 992       }
 993 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){
 994         return self->GetConnectionCount();
 995       }
 996 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 &)){
 997           self->Connect( func );
 998       }
 999 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 &)){
1000           self->Disconnect( func );
1001       }
1002 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){
1003           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1004 /*@SWIG@*/ self->Emit( arg );
1005       }
1006 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){
1007          return self->Empty();
1008       }
1009 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){
1010         return self->GetConnectionCount();
1011       }
1012 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 &)){
1013         self->Connect( func );
1014       }
1015 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 &)){
1016         self->Disconnect( func );
1017       }
1018 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){
1019         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1020 /*@SWIG@*/ self->Emit( arg1, arg2 );
1021       }
1022 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){
1023          return self->Empty();
1024       }
1025 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){
1026         return self->GetConnectionCount();
1027       }
1028 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 &)){
1029         self->Connect( func );
1030       }
1031 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 &)){
1032         self->Disconnect( func );
1033       }
1034 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){
1035         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1036 /*@SWIG@*/ self->Emit( arg1, arg2 );
1037       }
1038 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){
1039          return self->Empty();
1040       }
1041 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){
1042         return self->GetConnectionCount();
1043       }
1044 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 &)){
1045         self->Connect( func );
1046       }
1047 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 &)){
1048         self->Disconnect( func );
1049       }
1050 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){
1051         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1052 /*@SWIG@*/ self->Emit( arg1, arg2 );
1053       }
1054 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1055          return self->Empty();
1056       }
1057 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1058         return self->GetConnectionCount();
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1061           self->Connect( func );
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1064           self->Disconnect( func );
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1067           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1068 /*@SWIG@*/ self->Emit( arg );
1069       }
1070 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){
1071          return self->Empty();
1072       }
1073 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){
1074         return self->GetConnectionCount();
1075       }
1076 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)){
1077           return self->Connect( func );
1078       }
1079 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)){
1080           self->Disconnect( func );
1081       }
1082 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){
1083           self->Emit( arg1, arg3 );
1084       }
1085 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){
1086          return self->Empty();
1087       }
1088 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){
1089         return self->GetConnectionCount();
1090       }
1091 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)){
1092           return self->Connect( func );
1093       }
1094 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)){
1095           self->Disconnect( func );
1096       }
1097 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){
1098           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1099 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1100       }
1101
1102 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1103          return self->Empty();
1104       }
1105 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1106         return self->GetConnectionCount();
1107       }
1108 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1109           self->Connect( func );
1110       }
1111 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1112           self->Disconnect( func );
1113       }
1114 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1115           return self->Emit();
1116       }
1117
1118 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1119         std::vector< unsigned int >* pv = 0;
1120         if (capacity >= 0) {
1121           pv = new std::vector< unsigned int >();
1122           pv->reserve(capacity);
1123        } else {
1124           throw std::out_of_range("capacity");
1125        }
1126        return pv;
1127       }
1128 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1135         if (index>=0 && index<(int)self->size())
1136           return (*self)[index];
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1141         if (index>=0 && index<(int)self->size())
1142           (*self)[index] = val;
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1147         self->insert(self->end(), values.begin(), values.end());
1148       }
1149 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1150         if (index < 0)
1151           throw std::out_of_range("index");
1152         if (count < 0)
1153           throw std::out_of_range("count");
1154         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1155           throw std::invalid_argument("invalid range");
1156         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, x);
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1165         if (index>=0 && index<(int)self->size()+1)
1166           self->insert(self->begin()+index, values.begin(), values.end());
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1171         if (index>=0 && index<(int)self->size())
1172           self->erase(self->begin() + index);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1184       }
1185 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         return new std::vector< unsigned int >(count, value);
1189       }
1190 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1191         std::reverse(self->begin(), self->end());
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1199           throw std::invalid_argument("invalid range");
1200         std::reverse(self->begin()+index, self->begin()+index+count);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1203         if (index < 0)
1204           throw std::out_of_range("index");
1205         if (index+values.size() > self->size())
1206           throw std::out_of_range("index");
1207         std::copy(values.begin(), values.end(), self->begin()+index);
1208       }
1209 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1210         return std::find(self->begin(), self->end(), value) != self->end();
1211       }
1212 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1213         int index = -1;
1214         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1215         if (it != self->end())
1216           index = (int)(it - self->begin());
1217         return index;
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1222         if (rit != self->rend())
1223           index = (int)(self->rend() - 1 - rit);
1224         return index;
1225       }
1226 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1227         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1228         if (it != self->end()) {
1229           self->erase(it);
1230           return true;
1231         }
1232         return false;
1233       }
1234 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){
1235         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1236         if (capacity >= 0) {
1237           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1238           pv->reserve(capacity);
1239        } else {
1240           throw std::out_of_range("capacity");
1241        }
1242        return pv;
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           return (*self)[index];
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           (*self)[index] = val;
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 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){
1263         self->insert(self->end(), values.begin(), values.end());
1264       }
1265 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){
1266         if (index < 0)
1267           throw std::out_of_range("index");
1268         if (count < 0)
1269           throw std::out_of_range("count");
1270         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1271           throw std::invalid_argument("invalid range");
1272         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, x);
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size()+1)
1282           self->insert(self->begin()+index, values.begin(), values.end());
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 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){
1287         if (index>=0 && index<(int)self->size())
1288           self->erase(self->begin() + index);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 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){
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         self->erase(self->begin()+index, self->begin()+index+count);
1300       }
1301 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){
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1305       }
1306 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){
1307         std::reverse(self->begin(), self->end());
1308       }
1309 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){
1310         if (index < 0)
1311           throw std::out_of_range("index");
1312         if (count < 0)
1313           throw std::out_of_range("count");
1314         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1315           throw std::invalid_argument("invalid range");
1316         std::reverse(self->begin()+index, self->begin()+index+count);
1317       }
1318 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){
1319         if (index < 0)
1320           throw std::out_of_range("index");
1321         if (index+values.size() > self->size())
1322           throw std::out_of_range("index");
1323         std::copy(values.begin(), values.end(), self->begin()+index);
1324       }
1325 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1326         std::vector< Dali::Actor >* pv = 0;
1327         if (capacity >= 0) {
1328           pv = new std::vector< Dali::Actor >();
1329           pv->reserve(capacity);
1330        } else {
1331           throw std::out_of_range("capacity");
1332        }
1333        return pv;
1334       }
1335 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1342         if (index>=0 && index<(int)self->size())
1343           return (*self)[index];
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1348         if (index>=0 && index<(int)self->size())
1349           (*self)[index] = val;
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1354         self->insert(self->end(), values.begin(), values.end());
1355       }
1356 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1357         if (index < 0)
1358           throw std::out_of_range("index");
1359         if (count < 0)
1360           throw std::out_of_range("count");
1361         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1362           throw std::invalid_argument("invalid range");
1363         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, x);
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1372         if (index>=0 && index<(int)self->size()+1)
1373           self->insert(self->begin()+index, values.begin(), values.end());
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1378         if (index>=0 && index<(int)self->size())
1379           self->erase(self->begin() + index);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1391       }
1392 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         return new std::vector< Dali::Actor >(count, value);
1396       }
1397 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1398         std::reverse(self->begin(), self->end());
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1401         if (index < 0)
1402           throw std::out_of_range("index");
1403         if (count < 0)
1404           throw std::out_of_range("count");
1405         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1406           throw std::invalid_argument("invalid range");
1407         std::reverse(self->begin()+index, self->begin()+index+count);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1410         if (index < 0)
1411           throw std::out_of_range("index");
1412         if (index+values.size() > self->size())
1413           throw std::out_of_range("index");
1414         std::copy(values.begin(), values.end(), self->begin()+index);
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 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 &)){
1423           self->Connect( func );
1424       }
1425 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 &)){
1426           self->Disconnect( func );
1427       }
1428 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){
1429           return self->Emit( arg );
1430       }
1431 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){
1432          return self->Empty();
1433       }
1434 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){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438         self->Connect( func );
1439       }
1440 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)){
1441         self->Disconnect( func );
1442       }
1443 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){
1444         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg1, arg2 );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1448          return self->Empty();
1449       }
1450 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){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454         self->Connect( func );
1455       }
1456 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)){
1457         self->Disconnect( func );
1458       }
1459 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){
1460         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470         self->Connect( func );
1471       }
1472 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)){
1473         self->Disconnect( func );
1474       }
1475 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){
1476         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg1, arg2 );
1478       }
1479 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){
1480          return self->Empty();
1481       }
1482 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){
1483         return self->GetConnectionCount();
1484       }
1485 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)){
1486         self->Connect( func );
1487       }
1488 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)){
1489         self->Disconnect( func );
1490       }
1491 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){
1492         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg1, arg2 );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1496          return self->Empty();
1497       }
1498 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1499         return self->GetConnectionCount();
1500       }
1501 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)){
1502           self->Connect( func );
1503       }
1504 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)){
1505           self->Disconnect( func );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1508           return self->Emit( arg );
1509       }
1510 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1511          return self->Empty();
1512       }
1513 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1514         return self->GetConnectionCount();
1515       }
1516 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)){
1517           self->Connect( func );
1518       }
1519 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)){
1520           self->Disconnect( func );
1521       }
1522 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1523           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1524 /*@SWIG@*/ self->Emit( arg );
1525       }
1526 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){
1527          return self->Empty();
1528       }
1529 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){
1530         return self->GetConnectionCount();
1531       }
1532 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)){
1533           return self->Connect( func );
1534       }
1535 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)){
1536           self->Disconnect( func );
1537       }
1538 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){
1539           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1540 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1541       }
1542 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1543          return self->Empty();
1544       }
1545 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1546         return self->GetConnectionCount();
1547       }
1548 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)){
1549           self->Connect( func );
1550       }
1551 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)){
1552           self->Disconnect( func );
1553       }
1554 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1555           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1556 /*@SWIG@*/ self->Emit( arg );
1557       }
1558 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){
1559          return self->Empty();
1560       }
1561 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){
1562         return self->GetConnectionCount();
1563       }
1564 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)){
1565           return self->Connect( func );
1566       }
1567 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)){
1568           self->Disconnect( func );
1569       }
1570 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){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1573       }
1574 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){
1575          return self->Empty();
1576       }
1577 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){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1591          return self->Empty();
1592       }
1593 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){
1594         return self->GetConnectionCount();
1595       }
1596 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 &)){
1597           self->Connect( func );
1598       }
1599 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 &)){
1600           self->Disconnect( func );
1601       }
1602 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){
1603           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1604 /*@SWIG@*/ self->Emit( arg );
1605       }
1606
1607
1608 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){
1609          return self->Empty();
1610       }
1611 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){
1612         return self->GetConnectionCount();
1613       }
1614 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 &)){
1615         self->Connect( func );
1616       }
1617 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 &)){
1618         self->Disconnect( func );
1619       }
1620 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){
1621         return self->Emit( arg1, arg2 );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 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)){
1630           self->Connect( func );
1631       }
1632 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)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1640          return self->Empty();
1641       }
1642 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1643         return self->GetConnectionCount();
1644       }
1645 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 &)){
1646           self->Connect( func );
1647       }
1648 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 &)){
1649           self->Disconnect( func );
1650       }
1651 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){
1652           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1653 /*@SWIG@*/ self->Emit( arg );
1654       }
1655 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1656          return self->Empty();
1657       }
1658 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){
1659         return self->GetConnectionCount();
1660       }
1661 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)){
1662         self->Connect( func );
1663       }
1664 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)){
1665         self->Disconnect( func );
1666       }
1667 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){
1668         return self->Emit( arg1, arg2 );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1671          return self->Empty();
1672       }
1673 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){
1674         return self->GetConnectionCount();
1675       }
1676 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)){
1677         self->Connect( func );
1678       }
1679 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)){
1680         self->Disconnect( func );
1681       }
1682 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){
1683         return self->Emit( arg1, arg2 );
1684       }
1685
1686
1687 /* ---------------------------------------------------
1688  * C++ director class methods
1689  * --------------------------------------------------- */
1690
1691 #include "dali_wrap.h"
1692
1693 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1694   swig_init_callbacks();
1695 }
1696
1697 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1698
1699 }
1700
1701
1702 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1703   int jdepth  ;
1704
1705   if (!swig_callbackOnStageConnection) {
1706     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1707     return;
1708   } else {
1709     jdepth = depth;
1710     swig_callbackOnStageConnection(jdepth);
1711   }
1712 }
1713
1714 void SwigDirector_ViewImpl::OnStageDisconnection() {
1715   if (!swig_callbackOnStageDisconnection) {
1716     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1717     return;
1718   } else {
1719     swig_callbackOnStageDisconnection();
1720   }
1721 }
1722
1723 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1724   void * jchild = 0 ;
1725
1726   if (!swig_callbackOnChildAdd) {
1727     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1728     return;
1729   } else {
1730     jchild = (Dali::Actor *) &child;
1731     swig_callbackOnChildAdd(jchild);
1732   }
1733 }
1734
1735 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1736   void * jchild = 0 ;
1737
1738   if (!swig_callbackOnChildRemove) {
1739     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1740     return;
1741   } else {
1742     jchild = (Dali::Actor *) &child;
1743     swig_callbackOnChildRemove(jchild);
1744   }
1745 }
1746
1747 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1748   int jindex  ;
1749   void * jpropertyValue  ;
1750
1751   if (!swig_callbackOnPropertySet) {
1752     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1753     return;
1754   } else {
1755     jindex = index;
1756     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1757     swig_callbackOnPropertySet(jindex, jpropertyValue);
1758   }
1759 }
1760
1761 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1762   void * jtargetSize = 0 ;
1763
1764   if (!swig_callbackOnSizeSet) {
1765     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1766     return;
1767   } else {
1768     jtargetSize = (Dali::Vector3 *) &targetSize;
1769     swig_callbackOnSizeSet(jtargetSize);
1770   }
1771 }
1772
1773 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1774   void * janimation = 0 ;
1775   void * jtargetSize = 0 ;
1776
1777   if (!swig_callbackOnSizeAnimation) {
1778     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1779     return;
1780   } else {
1781     janimation = (Dali::Animation *) &animation;
1782     jtargetSize = (Dali::Vector3 *) &targetSize;
1783     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1784   }
1785 }
1786
1787 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1788   bool c_result = SwigValueInit< bool >() ;
1789   unsigned int jresult = 0 ;
1790   void * jarg0 = 0 ;
1791
1792   if (!swig_callbackOnTouchEvent) {
1793     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1794   } else {
1795     jarg0 = (Dali::TouchEvent *) &event;
1796     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1797     c_result = jresult ? true : false;
1798   }
1799   return c_result;
1800 }
1801
1802 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1803   bool c_result = SwigValueInit< bool >() ;
1804   unsigned int jresult = 0 ;
1805   void * jarg0 = 0 ;
1806
1807   if (!swig_callbackOnHoverEvent) {
1808     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1809   } else {
1810     jarg0 = (Dali::HoverEvent *) &event;
1811     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1812     c_result = jresult ? true : false;
1813   }
1814   return c_result;
1815 }
1816
1817 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1818   bool c_result = SwigValueInit< bool >() ;
1819   unsigned int jresult = 0 ;
1820   void * jarg0 = 0 ;
1821
1822   if (!swig_callbackOnKeyEvent) {
1823     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1824   } else {
1825     jarg0 = (Dali::KeyEvent *) &event;
1826     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1827     c_result = jresult ? true : false;
1828   }
1829   return c_result;
1830 }
1831
1832 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1833   bool c_result = SwigValueInit< bool >() ;
1834   unsigned int jresult = 0 ;
1835   void * jarg0 = 0 ;
1836
1837   if (!swig_callbackOnWheelEvent) {
1838     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1839   } else {
1840     jarg0 = (Dali::WheelEvent *) &event;
1841     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1842     c_result = jresult ? true : false;
1843   }
1844   return c_result;
1845 }
1846
1847 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1848   void * jsize = 0 ;
1849   void * jcontainer = 0 ;
1850
1851   if (!swig_callbackOnRelayout) {
1852     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1853     return;
1854   } else {
1855     jsize = (Dali::Vector2 *) &size;
1856     jcontainer = (Dali::RelayoutContainer *) &container;
1857     swig_callbackOnRelayout(jsize, jcontainer);
1858   }
1859 }
1860
1861 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1862   int jpolicy  ;
1863   int jdimension  ;
1864
1865   if (!swig_callbackOnSetResizePolicy) {
1866     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1867     return;
1868   } else {
1869     jpolicy = (int)policy;
1870     jdimension = (int)dimension;
1871     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1872   }
1873 }
1874
1875 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1876   Dali::Vector3 c_result ;
1877   void * jresult = 0 ;
1878
1879   if (!swig_callbackGetNaturalSize) {
1880     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1881   } else {
1882     jresult = (void *) swig_callbackGetNaturalSize();
1883     if (!jresult) {
1884       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1885       return c_result;
1886     }
1887     c_result = *(Dali::Vector3 *)jresult;
1888   }
1889   return c_result;
1890 }
1891
1892 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1893   float c_result = SwigValueInit< float >() ;
1894   float jresult = 0 ;
1895   void * jchild = 0 ;
1896   int jdimension  ;
1897
1898   if (!swig_callbackCalculateChildSize) {
1899     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1900   } else {
1901     jchild = (Dali::Actor *) &child;
1902     jdimension = (int)dimension;
1903     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1904     c_result = (float)jresult;
1905   }
1906   return c_result;
1907 }
1908
1909 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1910   float c_result = SwigValueInit< float >() ;
1911   float jresult = 0 ;
1912   float jwidth  ;
1913
1914   if (!swig_callbackGetHeightForWidth) {
1915     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1916   } else {
1917     jwidth = width;
1918     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1919     c_result = (float)jresult;
1920   }
1921   return c_result;
1922 }
1923
1924 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1925   float c_result = SwigValueInit< float >() ;
1926   float jresult = 0 ;
1927   float jheight  ;
1928
1929   if (!swig_callbackGetWidthForHeight) {
1930     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1931   } else {
1932     jheight = height;
1933     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1934     c_result = (float)jresult;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   int jdimension  ;
1943
1944   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1945     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1946   } else {
1947     jdimension = (int)dimension;
1948     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1955   int jdimension  ;
1956
1957   if (!swig_callbackOnCalculateRelayoutSize) {
1958     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1959     return;
1960   } else {
1961     jdimension = (int)dimension;
1962     swig_callbackOnCalculateRelayoutSize(jdimension);
1963   }
1964 }
1965
1966 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1967   float jsize  ;
1968   int jdimension  ;
1969
1970   if (!swig_callbackOnLayoutNegotiated) {
1971     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1972     return;
1973   } else {
1974     jsize = size;
1975     jdimension = (int)dimension;
1976     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1977   }
1978 }
1979
1980 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1981   return Dali::CustomActorImpl::GetExtension();
1982 }
1983
1984 void SwigDirector_ViewImpl::OnInitialize() {
1985   if (!swig_callbackOnInitialize) {
1986     Dali::Toolkit::Internal::Control::OnInitialize();
1987     return;
1988   } else {
1989     swig_callbackOnInitialize();
1990   }
1991 }
1992
1993 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1994   void * jchild = 0 ;
1995
1996   if (!swig_callbackOnControlChildAdd) {
1997     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1998     return;
1999   } else {
2000     jchild = (Dali::Actor *) &child;
2001     swig_callbackOnControlChildAdd(jchild);
2002   }
2003 }
2004
2005 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2006   void * jchild = 0 ;
2007
2008   if (!swig_callbackOnControlChildRemove) {
2009     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2010     return;
2011   } else {
2012     jchild = (Dali::Actor *) &child;
2013     swig_callbackOnControlChildRemove(jchild);
2014   }
2015 }
2016
2017 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2018   void * jstyleManager  ;
2019   int jchange  ;
2020
2021   if (!swig_callbackOnStyleChange) {
2022     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2023     return;
2024   } else {
2025     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2026     jchange = (int)change;
2027     swig_callbackOnStyleChange(jstyleManager, jchange);
2028   }
2029 }
2030
2031 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2032   bool c_result = SwigValueInit< bool >() ;
2033   unsigned int jresult = 0 ;
2034
2035   if (!swig_callbackOnAccessibilityActivated) {
2036     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2037   } else {
2038     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2039     c_result = jresult ? true : false;
2040   }
2041   return c_result;
2042 }
2043
2044 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2045   bool c_result = SwigValueInit< bool >() ;
2046   unsigned int jresult = 0 ;
2047   void * jgesture  ;
2048
2049   if (!swig_callbackOnAccessibilityPan) {
2050     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2051   } else {
2052     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2053     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2054     c_result = jresult ? true : false;
2055   }
2056   return c_result;
2057 }
2058
2059 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2060   bool c_result = SwigValueInit< bool >() ;
2061   unsigned int jresult = 0 ;
2062   void * jtouchEvent = 0 ;
2063
2064   if (!swig_callbackOnAccessibilityTouch) {
2065     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2066   } else {
2067     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2068     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2069     c_result = jresult ? true : false;
2070   }
2071   return c_result;
2072 }
2073
2074 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2075   bool c_result = SwigValueInit< bool >() ;
2076   unsigned int jresult = 0 ;
2077   unsigned int jisIncrease  ;
2078
2079   if (!swig_callbackOnAccessibilityValueChange) {
2080     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2081   } else {
2082     jisIncrease = isIncrease;
2083     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2084     c_result = jresult ? true : false;
2085   }
2086   return c_result;
2087 }
2088
2089 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2090   bool c_result = SwigValueInit< bool >() ;
2091   unsigned int jresult = 0 ;
2092
2093   if (!swig_callbackOnAccessibilityZoom) {
2094     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2095   } else {
2096     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2097     c_result = jresult ? true : false;
2098   }
2099   return c_result;
2100 }
2101
2102 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2103   if (!swig_callbackOnKeyInputFocusGained) {
2104     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2105     return;
2106   } else {
2107     swig_callbackOnKeyInputFocusGained();
2108   }
2109 }
2110
2111 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2112   if (!swig_callbackOnKeyInputFocusLost) {
2113     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2114     return;
2115   } else {
2116     swig_callbackOnKeyInputFocusLost();
2117   }
2118 }
2119
2120 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2121   Dali::Actor c_result ;
2122   void * jresult = 0 ;
2123   void * jcurrentFocusedActor  ;
2124   int jdirection  ;
2125   unsigned int jloopEnabled  ;
2126
2127   if (!swig_callbackGetNextKeyboardFocusableActor) {
2128     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2129   } else {
2130     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2131     jdirection = (int)direction;
2132     jloopEnabled = loopEnabled;
2133     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2134     if (!jresult) {
2135       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2136       return c_result;
2137     }
2138     c_result = *(Dali::Actor *)jresult;
2139   }
2140   return c_result;
2141 }
2142
2143 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2144   void * jcommitedFocusableActor  ;
2145
2146   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2147     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2148     return;
2149   } else {
2150     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2151     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2152   }
2153 }
2154
2155 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2156   bool c_result = SwigValueInit< bool >() ;
2157   unsigned int jresult = 0 ;
2158
2159   if (!swig_callbackOnKeyboardEnter) {
2160     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2161   } else {
2162     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2163     c_result = jresult ? true : false;
2164   }
2165   return c_result;
2166 }
2167
2168 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2169   void * jpinch = 0 ;
2170
2171   if (!swig_callbackOnPinch) {
2172     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2173     return;
2174   } else {
2175     jpinch = (Dali::PinchGesture *) &pinch;
2176     swig_callbackOnPinch(jpinch);
2177   }
2178 }
2179
2180 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2181   void * jpan = 0 ;
2182
2183   if (!swig_callbackOnPan) {
2184     Dali::Toolkit::Internal::Control::OnPan(pan);
2185     return;
2186   } else {
2187     jpan = (Dali::PanGesture *) &pan;
2188     swig_callbackOnPan(jpan);
2189   }
2190 }
2191
2192 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2193   void * jtap = 0 ;
2194
2195   if (!swig_callbackOnTap) {
2196     Dali::Toolkit::Internal::Control::OnTap(tap);
2197     return;
2198   } else {
2199     jtap = (Dali::TapGesture *) &tap;
2200     swig_callbackOnTap(jtap);
2201   }
2202 }
2203
2204 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2205   void * jlongPress = 0 ;
2206
2207   if (!swig_callbackOnLongPress) {
2208     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2209     return;
2210   } else {
2211     jlongPress = (Dali::LongPressGesture *) &longPress;
2212     swig_callbackOnLongPress(jlongPress);
2213   }
2214 }
2215
2216 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2217   void * jslotObserver = 0 ;
2218   void * jcallback = 0 ;
2219
2220   if (!swig_callbackSignalConnected) {
2221     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2222     return;
2223   } else {
2224     jslotObserver = (void *) slotObserver;
2225     jcallback = (void *) callback;
2226     swig_callbackSignalConnected(jslotObserver, jcallback);
2227   }
2228 }
2229
2230 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2231   void * jslotObserver = 0 ;
2232   void * jcallback = 0 ;
2233
2234   if (!swig_callbackSignalDisconnected) {
2235     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2236     return;
2237   } else {
2238     jslotObserver = (void *) slotObserver;
2239     jcallback = (void *) callback;
2240     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2241   }
2242 }
2243
2244 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2245   return Dali::Toolkit::Internal::Control::GetControlExtension();
2246 }
2247
2248 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) {
2249   swig_callbackOnStageConnection = callbackOnStageConnection;
2250   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2251   swig_callbackOnChildAdd = callbackOnChildAdd;
2252   swig_callbackOnChildRemove = callbackOnChildRemove;
2253   swig_callbackOnPropertySet = callbackOnPropertySet;
2254   swig_callbackOnSizeSet = callbackOnSizeSet;
2255   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2256   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2257   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2258   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2259   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2260   swig_callbackOnRelayout = callbackOnRelayout;
2261   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2262   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2263   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2264   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2265   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2266   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2267   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2268   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2269   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2270   swig_callbackOnInitialize = callbackOnInitialize;
2271   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2272   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2273   swig_callbackOnStyleChange = callbackOnStyleChange;
2274   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2275   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2276   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2277   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2278   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2279   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2280   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2281   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2282   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2283   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2284   swig_callbackOnPinch = callbackOnPinch;
2285   swig_callbackOnPan = callbackOnPan;
2286   swig_callbackOnTap = callbackOnTap;
2287   swig_callbackOnLongPress = callbackOnLongPress;
2288   swig_callbackSignalConnected = callbackSignalConnected;
2289   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2290 }
2291
2292 void SwigDirector_ViewImpl::swig_init_callbacks() {
2293   swig_callbackOnStageConnection = 0;
2294   swig_callbackOnStageDisconnection = 0;
2295   swig_callbackOnChildAdd = 0;
2296   swig_callbackOnChildRemove = 0;
2297   swig_callbackOnPropertySet = 0;
2298   swig_callbackOnSizeSet = 0;
2299   swig_callbackOnSizeAnimation = 0;
2300   swig_callbackOnTouchEvent = 0;
2301   swig_callbackOnHoverEvent = 0;
2302   swig_callbackOnKeyEvent = 0;
2303   swig_callbackOnWheelEvent = 0;
2304   swig_callbackOnRelayout = 0;
2305   swig_callbackOnSetResizePolicy = 0;
2306   swig_callbackGetNaturalSize = 0;
2307   swig_callbackCalculateChildSize = 0;
2308   swig_callbackGetHeightForWidth = 0;
2309   swig_callbackGetWidthForHeight = 0;
2310   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2311   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2312   swig_callbackOnCalculateRelayoutSize = 0;
2313   swig_callbackOnLayoutNegotiated = 0;
2314   swig_callbackOnInitialize = 0;
2315   swig_callbackOnControlChildAdd = 0;
2316   swig_callbackOnControlChildRemove = 0;
2317   swig_callbackOnStyleChange = 0;
2318   swig_callbackOnAccessibilityActivated = 0;
2319   swig_callbackOnAccessibilityPan = 0;
2320   swig_callbackOnAccessibilityTouch = 0;
2321   swig_callbackOnAccessibilityValueChange = 0;
2322   swig_callbackOnAccessibilityZoom = 0;
2323   swig_callbackOnKeyInputFocusGained = 0;
2324   swig_callbackOnKeyInputFocusLost = 0;
2325   swig_callbackGetNextKeyboardFocusableActor = 0;
2326   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2327   swig_callbackOnKeyboardEnter = 0;
2328   swig_callbackOnPinch = 0;
2329   swig_callbackOnPan = 0;
2330   swig_callbackOnTap = 0;
2331   swig_callbackOnLongPress = 0;
2332   swig_callbackSignalConnected = 0;
2333   swig_callbackSignalDisconnected = 0;
2334 }
2335
2336 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2337   swig_init_callbacks();
2338 }
2339
2340 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2341
2342 }
2343
2344
2345 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2346   unsigned int c_result = SwigValueInit< unsigned int >() ;
2347   unsigned int jresult = 0 ;
2348
2349   if (!swig_callbackGetNumberOfItems) {
2350     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2351   } else {
2352     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2353     c_result = (unsigned int)jresult;
2354   }
2355   return c_result;
2356 }
2357
2358 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2359   Dali::Actor c_result ;
2360   void * jresult = 0 ;
2361   unsigned int jitemId  ;
2362
2363   if (!swig_callbackNewItem) {
2364     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2365   } else {
2366     jitemId = itemId;
2367     jresult = (void *) swig_callbackNewItem(jitemId);
2368     if (!jresult) {
2369       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2370       return c_result;
2371     }
2372     c_result = *(Dali::Actor *)jresult;
2373   }
2374   return c_result;
2375 }
2376
2377 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2378   unsigned int jitemId  ;
2379   void * jactor  ;
2380
2381   if (!swig_callbackItemReleased) {
2382     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2383     return;
2384   } else {
2385     jitemId = itemId;
2386     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2387     swig_callbackItemReleased(jitemId, jactor);
2388   }
2389 }
2390
2391 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2392   return Dali::Toolkit::ItemFactory::GetExtension();
2393 }
2394
2395 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2396   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2397   swig_callbackNewItem = callbackNewItem;
2398   swig_callbackItemReleased = callbackItemReleased;
2399 }
2400
2401 void SwigDirector_ItemFactory::swig_init_callbacks() {
2402   swig_callbackGetNumberOfItems = 0;
2403   swig_callbackNewItem = 0;
2404   swig_callbackItemReleased = 0;
2405 }
2406
2407 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2408   swig_init_callbacks();
2409 }
2410
2411 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2412
2413 }
2414
2415
2416 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2417   Dali::Actor c_result ;
2418   void * jresult = 0 ;
2419   void * jcurrent  ;
2420   void * jproposed  ;
2421   int jdirection  ;
2422
2423   if (!swig_callbackGetNextFocusableActor) {
2424     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2425   } else {
2426     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2427     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2428     jdirection = (int)direction;
2429     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2430     if (!jresult) {
2431       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2432       return c_result;
2433     }
2434     c_result = *(Dali::Actor *)jresult;
2435   }
2436   return c_result;
2437 }
2438
2439 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2440   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2441 }
2442
2443 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2444   swig_callbackGetNextFocusableActor = 0;
2445 }
2446
2447
2448 #ifdef __cplusplus
2449 extern "C" {
2450 #endif
2451
2452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2453   void * jresult ;
2454   floatp *result = 0 ;
2455
2456   {
2457     try {
2458       result = (floatp *)new_floatp();
2459     } catch (std::out_of_range& e) {
2460       {
2461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2462       };
2463     } catch (std::exception& e) {
2464       {
2465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2466       };
2467     } catch (DaliException e) {
2468       {
2469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2470       };
2471     } catch (...) {
2472       {
2473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2474       };
2475     }
2476   }
2477   jresult = (void *)result;
2478   return jresult;
2479 }
2480
2481
2482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2483   floatp *arg1 = (floatp *) 0 ;
2484
2485   arg1 = (floatp *)jarg1;
2486   {
2487     try {
2488       delete_floatp(arg1);
2489     } catch (std::out_of_range& e) {
2490       {
2491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2492       };
2493     } catch (std::exception& e) {
2494       {
2495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2496       };
2497     } catch (Dali::DaliException e) {
2498       {
2499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2500       };
2501     } catch (...) {
2502       {
2503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2504       };
2505     }
2506   }
2507
2508 }
2509
2510
2511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2512   floatp *arg1 = (floatp *) 0 ;
2513   float arg2 ;
2514
2515   arg1 = (floatp *)jarg1;
2516   arg2 = (float)jarg2;
2517   {
2518     try {
2519       floatp_assign(arg1,arg2);
2520     } catch (std::out_of_range& e) {
2521       {
2522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2523       };
2524     } catch (std::exception& e) {
2525       {
2526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2527       };
2528     } catch (Dali::DaliException e) {
2529       {
2530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2531       };
2532     } catch (...) {
2533       {
2534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2535       };
2536     }
2537   }
2538
2539 }
2540
2541
2542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2543   float jresult ;
2544   floatp *arg1 = (floatp *) 0 ;
2545   float result;
2546
2547   arg1 = (floatp *)jarg1;
2548   {
2549     try {
2550       result = (float)floatp_value(arg1);
2551     } catch (std::out_of_range& e) {
2552       {
2553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2554       };
2555     } catch (std::exception& e) {
2556       {
2557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2558       };
2559     } catch (DaliException e) {
2560       {
2561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2562       };
2563     } catch (...) {
2564       {
2565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2566       };
2567     }
2568   }
2569   jresult = result;
2570   return jresult;
2571 }
2572
2573
2574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2575   void * jresult ;
2576   floatp *arg1 = (floatp *) 0 ;
2577   float *result = 0 ;
2578
2579   arg1 = (floatp *)jarg1;
2580   {
2581     try {
2582       result = (float *)floatp_cast(arg1);
2583     } catch (std::out_of_range& e) {
2584       {
2585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2586       };
2587     } catch (std::exception& e) {
2588       {
2589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2590       };
2591     } catch (Dali::DaliException e) {
2592       {
2593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2594       };
2595     } catch (...) {
2596       {
2597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2598       };
2599     }
2600   }
2601
2602   jresult = (void *)result;
2603   return jresult;
2604 }
2605
2606
2607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2608   void * jresult ;
2609   float *arg1 = (float *) 0 ;
2610   floatp *result = 0 ;
2611
2612   arg1 = (float *)jarg1;
2613   {
2614     try {
2615       result = (floatp *)floatp_frompointer(arg1);
2616     } catch (std::out_of_range& e) {
2617       {
2618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2619       };
2620     } catch (std::exception& e) {
2621       {
2622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2623       };
2624     } catch (Dali::DaliException e) {
2625       {
2626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2627       };
2628     } catch (...) {
2629       {
2630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2631       };
2632     }
2633   }
2634
2635   jresult = (void *)result;
2636   return jresult;
2637 }
2638
2639
2640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2641   void * jresult ;
2642   intp *result = 0 ;
2643
2644   {
2645     try {
2646       result = (intp *)new_intp();
2647     } catch (std::out_of_range& e) {
2648       {
2649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2650       };
2651     } catch (std::exception& e) {
2652       {
2653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2654       };
2655     } catch (Dali::DaliException e) {
2656       {
2657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2658       };
2659     } catch (...) {
2660       {
2661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2662       };
2663     }
2664   }
2665
2666   jresult = (void *)result;
2667   return jresult;
2668 }
2669
2670
2671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2672   intp *arg1 = (intp *) 0 ;
2673
2674   arg1 = (intp *)jarg1;
2675   {
2676     try {
2677       delete_intp(arg1);
2678     } catch (std::out_of_range& e) {
2679       {
2680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2681       };
2682     } catch (std::exception& e) {
2683       {
2684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2685       };
2686     } catch (Dali::DaliException e) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2693       };
2694     }
2695   }
2696
2697 }
2698
2699
2700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2701   intp *arg1 = (intp *) 0 ;
2702   int arg2 ;
2703
2704   arg1 = (intp *)jarg1;
2705   arg2 = (int)jarg2;
2706   {
2707     try {
2708       intp_assign(arg1,arg2);
2709     } catch (std::out_of_range& e) {
2710       {
2711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2712       };
2713     } catch (std::exception& e) {
2714       {
2715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2716       };
2717     } catch (Dali::DaliException e) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2720       };
2721     } catch (...) {
2722       {
2723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2724       };
2725     }
2726   }
2727
2728 }
2729
2730
2731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2732   int jresult ;
2733   intp *arg1 = (intp *) 0 ;
2734   int result;
2735
2736   arg1 = (intp *)jarg1;
2737   {
2738     try {
2739       result = (int)intp_value(arg1);
2740     } catch (std::out_of_range& e) {
2741       {
2742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (std::exception& e) {
2745       {
2746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2747       };
2748     } catch (Dali::DaliException e) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2751       };
2752     } catch (...) {
2753       {
2754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2755       };
2756     }
2757   }
2758
2759   jresult = result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2765   void * jresult ;
2766   intp *arg1 = (intp *) 0 ;
2767   int *result = 0 ;
2768
2769   arg1 = (intp *)jarg1;
2770   {
2771     try {
2772       result = (int *)intp_cast(arg1);
2773     } catch (std::out_of_range& e) {
2774       {
2775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2776       };
2777     } catch (std::exception& e) {
2778       {
2779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2780       };
2781     } catch (Dali::DaliException e) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2784       };
2785     } catch (...) {
2786       {
2787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2788       };
2789     }
2790   }
2791
2792   jresult = (void *)result;
2793   return jresult;
2794 }
2795
2796
2797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2798   void * jresult ;
2799   int *arg1 = (int *) 0 ;
2800   intp *result = 0 ;
2801
2802   arg1 = (int *)jarg1;
2803   {
2804     try {
2805       result = (intp *)intp_frompointer(arg1);
2806     } catch (std::out_of_range& e) {
2807       {
2808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2809       };
2810     } catch (std::exception& e) {
2811       {
2812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (Dali::DaliException e) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2817       };
2818     } catch (...) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2821       };
2822     }
2823   }
2824
2825   jresult = (void *)result;
2826   return jresult;
2827 }
2828
2829
2830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2831   void * jresult ;
2832   doublep *result = 0 ;
2833
2834   {
2835     try {
2836       result = (doublep *)new_doublep();
2837     } catch (std::out_of_range& e) {
2838       {
2839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2840       };
2841     } catch (std::exception& e) {
2842       {
2843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2844       };
2845     } catch (Dali::DaliException e) {
2846       {
2847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2848       };
2849     } catch (...) {
2850       {
2851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2852       };
2853     }
2854   }
2855
2856   jresult = (void *)result;
2857   return jresult;
2858 }
2859
2860
2861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2862   doublep *arg1 = (doublep *) 0 ;
2863
2864   arg1 = (doublep *)jarg1;
2865   {
2866     try {
2867       delete_doublep(arg1);
2868     } catch (std::out_of_range& e) {
2869       {
2870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2871       };
2872     } catch (std::exception& e) {
2873       {
2874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2875       };
2876     } catch (Dali::DaliException e) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2879       };
2880     } catch (...) {
2881       {
2882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2883       };
2884     }
2885   }
2886
2887 }
2888
2889
2890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2891   doublep *arg1 = (doublep *) 0 ;
2892   double arg2 ;
2893
2894   arg1 = (doublep *)jarg1;
2895   arg2 = (double)jarg2;
2896   {
2897     try {
2898       doublep_assign(arg1,arg2);
2899     } catch (std::out_of_range& e) {
2900       {
2901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2902       };
2903     } catch (std::exception& e) {
2904       {
2905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2906       };
2907     } catch (Dali::DaliException e) {
2908       {
2909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2910       };
2911     } catch (...) {
2912       {
2913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2914       };
2915     }
2916   }
2917
2918 }
2919
2920
2921 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2922   double jresult ;
2923   doublep *arg1 = (doublep *) 0 ;
2924   double result;
2925
2926   arg1 = (doublep *)jarg1;
2927   {
2928     try {
2929       result = (double)doublep_value(arg1);
2930     } catch (std::out_of_range& e) {
2931       {
2932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (std::exception& e) {
2935       {
2936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2937       };
2938     } catch (Dali::DaliException e) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2941       };
2942     } catch (...) {
2943       {
2944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2945       };
2946     }
2947   }
2948
2949   jresult = result;
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2955   void * jresult ;
2956   doublep *arg1 = (doublep *) 0 ;
2957   double *result = 0 ;
2958
2959   arg1 = (doublep *)jarg1;
2960   {
2961     try {
2962       result = (double *)doublep_cast(arg1);
2963     } catch (std::out_of_range& e) {
2964       {
2965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2966       };
2967     } catch (std::exception& e) {
2968       {
2969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2970       };
2971     } catch (Dali::DaliException e) {
2972       {
2973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2974       };
2975     } catch (...) {
2976       {
2977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2978       };
2979     }
2980   }
2981
2982   jresult = (void *)result;
2983   return jresult;
2984 }
2985
2986
2987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2988   void * jresult ;
2989   double *arg1 = (double *) 0 ;
2990   doublep *result = 0 ;
2991
2992   arg1 = (double *)jarg1;
2993   {
2994     try {
2995       result = (doublep *)doublep_frompointer(arg1);
2996     } catch (std::out_of_range& e) {
2997       {
2998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2999       };
3000     } catch (std::exception& e) {
3001       {
3002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3003       };
3004     } catch (Dali::DaliException e) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3007       };
3008     } catch (...) {
3009       {
3010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3011       };
3012     }
3013   }
3014
3015   jresult = (void *)result;
3016   return jresult;
3017 }
3018
3019
3020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3021   void * jresult ;
3022   uintp *result = 0 ;
3023
3024   {
3025     try {
3026       result = (uintp *)new_uintp();
3027     } catch (std::out_of_range& e) {
3028       {
3029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3030       };
3031     } catch (std::exception& e) {
3032       {
3033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3034       };
3035     } catch (Dali::DaliException e) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3038       };
3039     } catch (...) {
3040       {
3041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3042       };
3043     }
3044   }
3045
3046   jresult = (void *)result;
3047   return jresult;
3048 }
3049
3050
3051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3052   uintp *arg1 = (uintp *) 0 ;
3053
3054   arg1 = (uintp *)jarg1;
3055   {
3056     try {
3057       delete_uintp(arg1);
3058     } catch (std::out_of_range& e) {
3059       {
3060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3061       };
3062     } catch (std::exception& e) {
3063       {
3064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3065       };
3066     } catch (Dali::DaliException e) {
3067       {
3068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3069       };
3070     } catch (...) {
3071       {
3072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3073       };
3074     }
3075   }
3076
3077 }
3078
3079
3080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3081   uintp *arg1 = (uintp *) 0 ;
3082   unsigned int arg2 ;
3083
3084   arg1 = (uintp *)jarg1;
3085   arg2 = (unsigned int)jarg2;
3086   {
3087     try {
3088       uintp_assign(arg1,arg2);
3089     } catch (std::out_of_range& e) {
3090       {
3091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3092       };
3093     } catch (std::exception& e) {
3094       {
3095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3096       };
3097     } catch (Dali::DaliException e) {
3098       {
3099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3100       };
3101     } catch (...) {
3102       {
3103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3104       };
3105     }
3106   }
3107
3108 }
3109
3110
3111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3112   unsigned int jresult ;
3113   uintp *arg1 = (uintp *) 0 ;
3114   unsigned int result;
3115
3116   arg1 = (uintp *)jarg1;
3117   {
3118     try {
3119       result = (unsigned int)uintp_value(arg1);
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (Dali::DaliException e) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138
3139   jresult = result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3145   void * jresult ;
3146   uintp *arg1 = (uintp *) 0 ;
3147   unsigned int *result = 0 ;
3148
3149   arg1 = (uintp *)jarg1;
3150   {
3151     try {
3152       result = (unsigned int *)uintp_cast(arg1);
3153     } catch (std::out_of_range& e) {
3154       {
3155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3156       };
3157     } catch (std::exception& e) {
3158       {
3159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3160       };
3161     } catch (Dali::DaliException e) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3164       };
3165     } catch (...) {
3166       {
3167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3168       };
3169     }
3170   }
3171
3172   jresult = (void *)result;
3173   return jresult;
3174 }
3175
3176
3177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3178   void * jresult ;
3179   unsigned int *arg1 = (unsigned int *) 0 ;
3180   uintp *result = 0 ;
3181
3182   arg1 = (unsigned int *)jarg1;
3183   {
3184     try {
3185       result = (uintp *)uintp_frompointer(arg1);
3186     } catch (std::out_of_range& e) {
3187       {
3188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3189       };
3190     } catch (std::exception& e) {
3191       {
3192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3193       };
3194     } catch (Dali::DaliException e) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3197       };
3198     } catch (...) {
3199       {
3200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3201       };
3202     }
3203   }
3204
3205   jresult = (void *)result;
3206   return jresult;
3207 }
3208
3209
3210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3211   void * jresult ;
3212   ushortp *result = 0 ;
3213
3214   {
3215     try {
3216       result = (ushortp *)new_ushortp();
3217     } catch (std::out_of_range& e) {
3218       {
3219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3220       };
3221     } catch (std::exception& e) {
3222       {
3223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3224       };
3225     } catch (Dali::DaliException e) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3228       };
3229     } catch (...) {
3230       {
3231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3232       };
3233     }
3234   }
3235
3236   jresult = (void *)result;
3237   return jresult;
3238 }
3239
3240
3241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3242   ushortp *arg1 = (ushortp *) 0 ;
3243
3244   arg1 = (ushortp *)jarg1;
3245   {
3246     try {
3247       delete_ushortp(arg1);
3248     } catch (std::out_of_range& e) {
3249       {
3250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3251       };
3252     } catch (std::exception& e) {
3253       {
3254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3255       };
3256     } catch (Dali::DaliException e) {
3257       {
3258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3259       };
3260     } catch (...) {
3261       {
3262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3263       };
3264     }
3265   }
3266
3267 }
3268
3269
3270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3271   ushortp *arg1 = (ushortp *) 0 ;
3272   unsigned short arg2 ;
3273
3274   arg1 = (ushortp *)jarg1;
3275   arg2 = (unsigned short)jarg2;
3276   {
3277     try {
3278       ushortp_assign(arg1,arg2);
3279     } catch (std::out_of_range& e) {
3280       {
3281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3282       };
3283     } catch (std::exception& e) {
3284       {
3285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3286       };
3287     } catch (Dali::DaliException e) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3290       };
3291     } catch (...) {
3292       {
3293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3294       };
3295     }
3296   }
3297
3298 }
3299
3300
3301 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3302   unsigned short jresult ;
3303   ushortp *arg1 = (ushortp *) 0 ;
3304   unsigned short result;
3305
3306   arg1 = (ushortp *)jarg1;
3307   {
3308     try {
3309       result = (unsigned short)ushortp_value(arg1);
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (Dali::DaliException e) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3321       };
3322     } catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328
3329   jresult = result;
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3335   void * jresult ;
3336   ushortp *arg1 = (ushortp *) 0 ;
3337   unsigned short *result = 0 ;
3338
3339   arg1 = (ushortp *)jarg1;
3340   {
3341     try {
3342       result = (unsigned short *)ushortp_cast(arg1);
3343     } catch (std::out_of_range& e) {
3344       {
3345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3346       };
3347     } catch (std::exception& e) {
3348       {
3349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3350       };
3351     } catch (Dali::DaliException e) {
3352       {
3353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3354       };
3355     } catch (...) {
3356       {
3357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3358       };
3359     }
3360   }
3361
3362   jresult = (void *)result;
3363   return jresult;
3364 }
3365
3366
3367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3368   void * jresult ;
3369   unsigned short *arg1 = (unsigned short *) 0 ;
3370   ushortp *result = 0 ;
3371
3372   arg1 = (unsigned short *)jarg1;
3373   {
3374     try {
3375       result = (ushortp *)ushortp_frompointer(arg1);
3376     } catch (std::out_of_range& e) {
3377       {
3378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3379       };
3380     } catch (std::exception& e) {
3381       {
3382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3383       };
3384     } catch (Dali::DaliException e) {
3385       {
3386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3387       };
3388     } catch (...) {
3389       {
3390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3391       };
3392     }
3393   }
3394
3395   jresult = (void *)result;
3396   return jresult;
3397 }
3398
3399
3400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3401   unsigned int jresult ;
3402   int arg1 ;
3403   unsigned int result;
3404
3405   arg1 = (int)jarg1;
3406   {
3407     try {
3408       result = (unsigned int)int_to_uint(arg1);
3409     } catch (std::out_of_range& e) {
3410       {
3411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3412       };
3413     } catch (std::exception& e) {
3414       {
3415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3416       };
3417     } catch (Dali::DaliException e) {
3418       {
3419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3420       };
3421     } catch (...) {
3422       {
3423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3424       };
3425     }
3426   }
3427
3428   jresult = result;
3429   return jresult;
3430 }
3431
3432
3433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3434   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3435
3436   arg1 = (Dali::RefObject *)jarg1;
3437   {
3438     try {
3439       (arg1)->Reference();
3440     } catch (std::out_of_range& e) {
3441       {
3442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3443       };
3444     } catch (std::exception& e) {
3445       {
3446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3447       };
3448     } catch (Dali::DaliException e) {
3449       {
3450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3451       };
3452     } catch (...) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3455       };
3456     }
3457   }
3458
3459 }
3460
3461
3462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3463   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3464
3465   arg1 = (Dali::RefObject *)jarg1;
3466   {
3467     try {
3468       (arg1)->Unreference();
3469     } catch (std::out_of_range& e) {
3470       {
3471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3472       };
3473     } catch (std::exception& e) {
3474       {
3475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3476       };
3477     } catch (Dali::DaliException e) {
3478       {
3479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3480       };
3481     } catch (...) {
3482       {
3483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3484       };
3485     }
3486   }
3487
3488 }
3489
3490
3491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3492   int jresult ;
3493   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3494   int result;
3495
3496   arg1 = (Dali::RefObject *)jarg1;
3497   {
3498     try {
3499       result = (int)(arg1)->ReferenceCount();
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (Dali::DaliException e) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3511       };
3512     } catch (...) {
3513       {
3514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3515       };
3516     }
3517   }
3518
3519   jresult = result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3525   void * jresult ;
3526   Dali::Any *result = 0 ;
3527
3528   {
3529     try {
3530       result = (Dali::Any *)new Dali::Any();
3531     } catch (std::out_of_range& e) {
3532       {
3533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3534       };
3535     } catch (std::exception& e) {
3536       {
3537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3538       };
3539     } catch (Dali::DaliException e) {
3540       {
3541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3542       };
3543     } catch (...) {
3544       {
3545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3546       };
3547     }
3548   }
3549
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3556   Dali::Any *arg1 = (Dali::Any *) 0 ;
3557
3558   arg1 = (Dali::Any *)jarg1;
3559   {
3560     try {
3561       delete arg1;
3562     } catch (std::out_of_range& e) {
3563       {
3564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3565       };
3566     } catch (std::exception& e) {
3567       {
3568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3569       };
3570     } catch (Dali::DaliException e) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3573       };
3574     } catch (...) {
3575       {
3576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3577       };
3578     }
3579   }
3580
3581 }
3582
3583
3584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3585   char *arg1 = (char *) 0 ;
3586
3587   arg1 = (char *)jarg1;
3588   {
3589     try {
3590       Dali::Any::AssertAlways((char const *)arg1);
3591     } catch (std::out_of_range& e) {
3592       {
3593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3594       };
3595     } catch (std::exception& e) {
3596       {
3597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3598       };
3599     } catch (Dali::DaliException e) {
3600       {
3601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3602       };
3603     } catch (...) {
3604       {
3605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3606       };
3607     }
3608   }
3609
3610 }
3611
3612
3613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3614   void * jresult ;
3615   Dali::Any *arg1 = 0 ;
3616   Dali::Any *result = 0 ;
3617
3618   arg1 = (Dali::Any *)jarg1;
3619   if (!arg1) {
3620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3621     return 0;
3622   }
3623   {
3624     try {
3625       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3626     } catch (std::out_of_range& e) {
3627       {
3628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3629       };
3630     } catch (std::exception& e) {
3631       {
3632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3633       };
3634     } catch (Dali::DaliException e) {
3635       {
3636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3637       };
3638     } catch (...) {
3639       {
3640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3641       };
3642     }
3643   }
3644
3645   jresult = (void *)result;
3646   return jresult;
3647 }
3648
3649
3650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3651   void * jresult ;
3652   Dali::Any *arg1 = (Dali::Any *) 0 ;
3653   Dali::Any *arg2 = 0 ;
3654   Dali::Any *result = 0 ;
3655
3656   arg1 = (Dali::Any *)jarg1;
3657   arg2 = (Dali::Any *)jarg2;
3658   if (!arg2) {
3659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3660     return 0;
3661   }
3662   {
3663     try {
3664       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3665     } catch (std::out_of_range& e) {
3666       {
3667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3668       };
3669     } catch (std::exception& e) {
3670       {
3671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (Dali::DaliException e) {
3674       {
3675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3676       };
3677     } catch (...) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3680       };
3681     }
3682   }
3683
3684   jresult = (void *)result;
3685   return jresult;
3686 }
3687
3688
3689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3690   void * jresult ;
3691   Dali::Any *arg1 = (Dali::Any *) 0 ;
3692   std::type_info *result = 0 ;
3693
3694   arg1 = (Dali::Any *)jarg1;
3695   {
3696     try {
3697       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3698     } catch (std::out_of_range& e) {
3699       {
3700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3701       };
3702     } catch (std::exception& e) {
3703       {
3704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3705       };
3706     } catch (Dali::DaliException e) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3709       };
3710     } catch (...) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3713       };
3714     }
3715   }
3716
3717   jresult = (void *)result;
3718   return jresult;
3719 }
3720
3721
3722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3723   unsigned int jresult ;
3724   Dali::Any *arg1 = (Dali::Any *) 0 ;
3725   bool result;
3726
3727   arg1 = (Dali::Any *)jarg1;
3728   {
3729     try {
3730       result = (bool)((Dali::Any const *)arg1)->Empty();
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3746       };
3747     }
3748   }
3749
3750   jresult = result;
3751   return jresult;
3752 }
3753
3754
3755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3756   void * jresult ;
3757   std::type_info *arg1 = 0 ;
3758   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3759   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3760   Dali::Any::AnyContainerBase *result = 0 ;
3761
3762   arg1 = (std::type_info *)jarg1;
3763   if (!arg1) {
3764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3765     return 0;
3766   }
3767   arg2 = (Dali::Any::CloneFunc)jarg2;
3768   arg3 = (Dali::Any::DeleteFunc)jarg3;
3769   {
3770     try {
3771       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3772     } catch (std::out_of_range& e) {
3773       {
3774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3775       };
3776     } catch (std::exception& e) {
3777       {
3778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3779       };
3780     } catch (Dali::DaliException e) {
3781       {
3782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3783       };
3784     } catch (...) {
3785       {
3786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3787       };
3788     }
3789   }
3790
3791   jresult = (void *)result;
3792   return jresult;
3793 }
3794
3795
3796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3797   void * jresult ;
3798   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3799   std::type_info *result = 0 ;
3800
3801   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3802   {
3803     try {
3804       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3832   ::std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3835   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3836   jresult = (void *)result;
3837   return jresult;
3838 }
3839
3840
3841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3842   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3843   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3844
3845   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3846   arg2 = (Dali::Any::CloneFunc)jarg2;
3847   if (arg1) (arg1)->mCloneFunc = arg2;
3848 }
3849
3850
3851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3852   void * jresult ;
3853   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3854   Dali::Any::CloneFunc result;
3855
3856   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3857   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3858   jresult = (void *)result;
3859   return jresult;
3860 }
3861
3862
3863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3864   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3865   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3866
3867   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3868   arg2 = (Dali::Any::DeleteFunc)jarg2;
3869   if (arg1) (arg1)->mDeleteFunc = arg2;
3870 }
3871
3872
3873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3874   void * jresult ;
3875   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3876   Dali::Any::DeleteFunc result;
3877
3878   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3879   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3880   jresult = (void *)result;
3881   return jresult;
3882 }
3883
3884
3885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3886   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3887
3888   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3889   {
3890     try {
3891       delete arg1;
3892     } catch (std::out_of_range& e) {
3893       {
3894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3895       };
3896     } catch (std::exception& e) {
3897       {
3898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3899       };
3900     } catch (Dali::DaliException e) {
3901       {
3902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3903       };
3904     } catch (...) {
3905       {
3906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3907       };
3908     }
3909   }
3910
3911 }
3912
3913
3914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3915   Dali::Any *arg1 = (Dali::Any *) 0 ;
3916   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3917
3918   arg1 = (Dali::Any *)jarg1;
3919   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3920   if (arg1) (arg1)->mContainer = arg2;
3921 }
3922
3923
3924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3925   void * jresult ;
3926   Dali::Any *arg1 = (Dali::Any *) 0 ;
3927   Dali::Any::AnyContainerBase *result = 0 ;
3928
3929   arg1 = (Dali::Any *)jarg1;
3930   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3937   char *arg1 = (char *) 0 ;
3938   char *arg2 = (char *) 0 ;
3939
3940   arg1 = (char *)jarg1;
3941   arg2 = (char *)jarg2;
3942   {
3943     try {
3944       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3960       };
3961     }
3962   }
3963
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3968   void * jresult ;
3969   char *arg1 = (char *) 0 ;
3970   char *arg2 = (char *) 0 ;
3971   Dali::DaliException *result = 0 ;
3972
3973   arg1 = (char *)jarg1;
3974   arg2 = (char *)jarg2;
3975   {
3976     try {
3977       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3978     } catch (std::out_of_range& e) {
3979       {
3980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3981       };
3982     } catch (std::exception& e) {
3983       {
3984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3985       };
3986     } catch (Dali::DaliException e) {
3987       {
3988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3989       };
3990     } catch (...) {
3991       {
3992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3993       };
3994     }
3995   }
3996
3997   jresult = (void *)result;
3998   return jresult;
3999 }
4000
4001
4002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4003   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4004   std::string arg2 = std::string(jarg2);
4005
4006   arg1 = (Dali::DaliException *)jarg1;
4007   {
4008     if (!arg2.empty()) {
4009       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4010     } else {
4011       arg1->location = 0;
4012     }
4013   }
4014 }
4015
4016 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4017   char * jresult ;
4018   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4019   char *result = 0 ;
4020
4021   arg1 = (Dali::DaliException *)jarg1;
4022   result = (char *) ((arg1)->location);
4023   jresult = SWIG_csharp_string_callback((const char *)result);
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4029   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4030   std::string arg2 = std::string(jarg2);
4031
4032   arg1 = (Dali::DaliException *)jarg1;
4033   {
4034     if (!arg2.empty()) {
4035       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4036     } else {
4037       arg1->condition = 0;
4038     }
4039   }
4040 }
4041
4042
4043 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4044   char * jresult ;
4045   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4046   char *result = 0 ;
4047
4048   arg1 = (Dali::DaliException *)jarg1;
4049   result = (char *) ((arg1)->condition);
4050   jresult = SWIG_csharp_string_callback((const char *)result);
4051   return jresult;
4052 }
4053
4054
4055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4056   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4057
4058   arg1 = (Dali::DaliException *)jarg1;
4059   {
4060     try {
4061       delete arg1;
4062     } catch (std::out_of_range& e) {
4063       {
4064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4065       };
4066     } catch (std::exception& e) {
4067       {
4068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4069       };
4070     } catch (Dali::DaliException e) {
4071       {
4072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4073       };
4074     } catch (...) {
4075       {
4076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4077       };
4078     }
4079   }
4080
4081 }
4082
4083
4084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4085   void * jresult ;
4086   Dali::Vector2 *result = 0 ;
4087
4088   {
4089     try {
4090       result = (Dali::Vector2 *)new Dali::Vector2();
4091     } catch (std::out_of_range& e) {
4092       {
4093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4094       };
4095     } catch (std::exception& e) {
4096       {
4097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4098       };
4099     } catch (Dali::DaliException e) {
4100       {
4101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4102       };
4103     } catch (...) {
4104       {
4105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4106       };
4107     }
4108   }
4109
4110   jresult = (void *)result;
4111   return jresult;
4112 }
4113
4114
4115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4116   void * jresult ;
4117   float arg1 ;
4118   float arg2 ;
4119   Dali::Vector2 *result = 0 ;
4120
4121   arg1 = (float)jarg1;
4122   arg2 = (float)jarg2;
4123   {
4124     try {
4125       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4126     } catch (std::out_of_range& e) {
4127       {
4128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4129       };
4130     } catch (std::exception& e) {
4131       {
4132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4133       };
4134     } catch (Dali::DaliException e) {
4135       {
4136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4137       };
4138     } catch (...) {
4139       {
4140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4141       };
4142     }
4143   }
4144
4145   jresult = (void *)result;
4146   return jresult;
4147 }
4148
4149
4150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4151   void * jresult ;
4152   float *arg1 = (float *) 0 ;
4153   Dali::Vector2 *result = 0 ;
4154
4155   arg1 = jarg1;
4156   {
4157     try {
4158       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4159     } catch (std::out_of_range& e) {
4160       {
4161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4162       };
4163     } catch (std::exception& e) {
4164       {
4165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4166       };
4167     } catch (Dali::DaliException e) {
4168       {
4169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4170       };
4171     } catch (...) {
4172       {
4173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4174       };
4175     }
4176   }
4177
4178   jresult = (void *)result;
4179
4180
4181   return jresult;
4182 }
4183
4184
4185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4186   void * jresult ;
4187   Dali::Vector3 *arg1 = 0 ;
4188   Dali::Vector2 *result = 0 ;
4189
4190   arg1 = (Dali::Vector3 *)jarg1;
4191   if (!arg1) {
4192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4193     return 0;
4194   }
4195   {
4196     try {
4197       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4198     } catch (std::out_of_range& e) {
4199       {
4200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4201       };
4202     } catch (std::exception& e) {
4203       {
4204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4205       };
4206     } catch (Dali::DaliException e) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4209       };
4210     } catch (...) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4213       };
4214     }
4215   }
4216
4217   jresult = (void *)result;
4218   return jresult;
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4223   void * jresult ;
4224   Dali::Vector4 *arg1 = 0 ;
4225   Dali::Vector2 *result = 0 ;
4226
4227   arg1 = (Dali::Vector4 *)jarg1;
4228   if (!arg1) {
4229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4230     return 0;
4231   }
4232   {
4233     try {
4234       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4235     } catch (std::out_of_range& e) {
4236       {
4237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (std::exception& e) {
4240       {
4241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4242       };
4243     } catch (Dali::DaliException e) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4246       };
4247     } catch (...) {
4248       {
4249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4250       };
4251     }
4252   }
4253
4254   jresult = (void *)result;
4255   return jresult;
4256 }
4257
4258
4259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4260   void * jresult ;
4261   Dali::Vector2 *result = 0 ;
4262
4263   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4264   jresult = (void *)result;
4265   return jresult;
4266 }
4267
4268
4269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4270   void * jresult ;
4271   Dali::Vector2 *result = 0 ;
4272
4273   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4274   jresult = (void *)result;
4275   return jresult;
4276 }
4277
4278
4279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4280   void * jresult ;
4281   Dali::Vector2 *result = 0 ;
4282
4283   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4284   jresult = (void *)result;
4285   return jresult;
4286 }
4287
4288
4289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4290   void * jresult ;
4291   Dali::Vector2 *result = 0 ;
4292
4293   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4294   jresult = (void *)result;
4295   return jresult;
4296 }
4297
4298
4299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4300   void * jresult ;
4301   Dali::Vector2 *result = 0 ;
4302
4303   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4304   jresult = (void *)result;
4305   return jresult;
4306 }
4307
4308
4309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4310   void * jresult ;
4311   Dali::Vector2 *result = 0 ;
4312
4313   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4314   jresult = (void *)result;
4315   return jresult;
4316 }
4317
4318
4319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4320   void * jresult ;
4321   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4322   float *arg2 = (float *) 0 ;
4323   Dali::Vector2 *result = 0 ;
4324
4325   arg1 = (Dali::Vector2 *)jarg1;
4326   arg2 = jarg2;
4327   {
4328     try {
4329       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4330     } catch (std::out_of_range& e) {
4331       {
4332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (std::exception& e) {
4335       {
4336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4337       };
4338     } catch (Dali::DaliException e) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4341       };
4342     } catch (...) {
4343       {
4344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4345       };
4346     }
4347   }
4348
4349   jresult = (void *)result;
4350
4351
4352   return jresult;
4353 }
4354
4355
4356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4357   void * jresult ;
4358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4359   Dali::Vector3 *arg2 = 0 ;
4360   Dali::Vector2 *result = 0 ;
4361
4362   arg1 = (Dali::Vector2 *)jarg1;
4363   arg2 = (Dali::Vector3 *)jarg2;
4364   if (!arg2) {
4365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4366     return 0;
4367   }
4368   {
4369     try {
4370       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4371     } catch (std::out_of_range& e) {
4372       {
4373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4374       };
4375     } catch (std::exception& e) {
4376       {
4377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (Dali::DaliException e) {
4380       {
4381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4382       };
4383     } catch (...) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4386       };
4387     }
4388   }
4389
4390   jresult = (void *)result;
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4396   void * jresult ;
4397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4398   Dali::Vector4 *arg2 = 0 ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   arg1 = (Dali::Vector2 *)jarg1;
4402   arg2 = (Dali::Vector4 *)jarg2;
4403   if (!arg2) {
4404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4405     return 0;
4406   }
4407   {
4408     try {
4409       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4410     } catch (std::out_of_range& e) {
4411       {
4412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4413       };
4414     } catch (std::exception& e) {
4415       {
4416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4417       };
4418     } catch (Dali::DaliException e) {
4419       {
4420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4421       };
4422     } catch (...) {
4423       {
4424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4425       };
4426     }
4427   }
4428
4429   jresult = (void *)result;
4430   return jresult;
4431 }
4432
4433
4434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4435   void * jresult ;
4436   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4437   Dali::Vector2 *arg2 = 0 ;
4438   Dali::Vector2 result;
4439
4440   arg1 = (Dali::Vector2 *)jarg1;
4441   arg2 = (Dali::Vector2 *)jarg2;
4442   if (!arg2) {
4443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4444     return 0;
4445   }
4446   {
4447     try {
4448       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4449     } catch (std::out_of_range& e) {
4450       {
4451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4452       };
4453     } catch (std::exception& e) {
4454       {
4455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4456       };
4457     } catch (Dali::DaliException e) {
4458       {
4459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4460       };
4461     } catch (...) {
4462       {
4463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4464       };
4465     }
4466   }
4467
4468   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4469   return jresult;
4470 }
4471
4472
4473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4474   void * jresult ;
4475   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4476   Dali::Vector2 *arg2 = 0 ;
4477   Dali::Vector2 *result = 0 ;
4478
4479   arg1 = (Dali::Vector2 *)jarg1;
4480   arg2 = (Dali::Vector2 *)jarg2;
4481   if (!arg2) {
4482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4483     return 0;
4484   }
4485   {
4486     try {
4487       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4488     } catch (std::out_of_range& e) {
4489       {
4490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4491       };
4492     } catch (std::exception& e) {
4493       {
4494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4495       };
4496     } catch (Dali::DaliException e) {
4497       {
4498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4499       };
4500     } catch (...) {
4501       {
4502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4503       };
4504     }
4505   }
4506
4507   jresult = (void *)result;
4508   return jresult;
4509 }
4510
4511
4512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4513   void * jresult ;
4514   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4515   Dali::Vector2 *arg2 = 0 ;
4516   Dali::Vector2 result;
4517
4518   arg1 = (Dali::Vector2 *)jarg1;
4519   arg2 = (Dali::Vector2 *)jarg2;
4520   if (!arg2) {
4521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4522     return 0;
4523   }
4524   {
4525     try {
4526       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4527     } catch (std::out_of_range& e) {
4528       {
4529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4530       };
4531     } catch (std::exception& e) {
4532       {
4533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4534       };
4535     } catch (Dali::DaliException e) {
4536       {
4537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4538       };
4539     } catch (...) {
4540       {
4541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4542       };
4543     }
4544   }
4545
4546   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4547   return jresult;
4548 }
4549
4550
4551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4552   void * jresult ;
4553   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4554   Dali::Vector2 *arg2 = 0 ;
4555   Dali::Vector2 *result = 0 ;
4556
4557   arg1 = (Dali::Vector2 *)jarg1;
4558   arg2 = (Dali::Vector2 *)jarg2;
4559   if (!arg2) {
4560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4561     return 0;
4562   }
4563   {
4564     try {
4565       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4566     } catch (std::out_of_range& e) {
4567       {
4568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4569       };
4570     } catch (std::exception& e) {
4571       {
4572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (Dali::DaliException e) {
4575       {
4576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4577       };
4578     } catch (...) {
4579       {
4580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4581       };
4582     }
4583   }
4584
4585   jresult = (void *)result;
4586   return jresult;
4587 }
4588
4589
4590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4591   void * jresult ;
4592   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4593   Dali::Vector2 *arg2 = 0 ;
4594   Dali::Vector2 result;
4595
4596   arg1 = (Dali::Vector2 *)jarg1;
4597   arg2 = (Dali::Vector2 *)jarg2;
4598   if (!arg2) {
4599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4600     return 0;
4601   }
4602   {
4603     try {
4604       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4605     } catch (std::out_of_range& e) {
4606       {
4607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4608       };
4609     } catch (std::exception& e) {
4610       {
4611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4612       };
4613     } catch (Dali::DaliException e) {
4614       {
4615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4616       };
4617     } catch (...) {
4618       {
4619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4620       };
4621     }
4622   }
4623
4624   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4625   return jresult;
4626 }
4627
4628
4629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4630   void * jresult ;
4631   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4632   float arg2 ;
4633   Dali::Vector2 result;
4634
4635   arg1 = (Dali::Vector2 *)jarg1;
4636   arg2 = (float)jarg2;
4637   {
4638     try {
4639       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4640     } catch (std::out_of_range& e) {
4641       {
4642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4643       };
4644     } catch (std::exception& e) {
4645       {
4646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4647       };
4648     } catch (Dali::DaliException e) {
4649       {
4650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4651       };
4652     } catch (...) {
4653       {
4654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4655       };
4656     }
4657   }
4658
4659   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4660   return jresult;
4661 }
4662
4663
4664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4665   void * jresult ;
4666   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4667   Dali::Vector2 *arg2 = 0 ;
4668   Dali::Vector2 *result = 0 ;
4669
4670   arg1 = (Dali::Vector2 *)jarg1;
4671   arg2 = (Dali::Vector2 *)jarg2;
4672   if (!arg2) {
4673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4674     return 0;
4675   }
4676   {
4677     try {
4678       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4679     } catch (std::out_of_range& e) {
4680       {
4681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4682       };
4683     } catch (std::exception& e) {
4684       {
4685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4686       };
4687     } catch (Dali::DaliException e) {
4688       {
4689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4690       };
4691     } catch (...) {
4692       {
4693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4694       };
4695     }
4696   }
4697
4698   jresult = (void *)result;
4699   return jresult;
4700 }
4701
4702
4703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4704   void * jresult ;
4705   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4706   float arg2 ;
4707   Dali::Vector2 *result = 0 ;
4708
4709   arg1 = (Dali::Vector2 *)jarg1;
4710   arg2 = (float)jarg2;
4711   {
4712     try {
4713       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4714     } catch (std::out_of_range& e) {
4715       {
4716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4717       };
4718     } catch (std::exception& e) {
4719       {
4720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4721       };
4722     } catch (Dali::DaliException e) {
4723       {
4724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4725       };
4726     } catch (...) {
4727       {
4728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4729       };
4730     }
4731   }
4732
4733   jresult = (void *)result;
4734   return jresult;
4735 }
4736
4737
4738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4739   void * jresult ;
4740   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4741   Dali::Vector2 *arg2 = 0 ;
4742   Dali::Vector2 result;
4743
4744   arg1 = (Dali::Vector2 *)jarg1;
4745   arg2 = (Dali::Vector2 *)jarg2;
4746   if (!arg2) {
4747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4748     return 0;
4749   }
4750   {
4751     try {
4752       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4753     } catch (std::out_of_range& e) {
4754       {
4755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4756       };
4757     } catch (std::exception& e) {
4758       {
4759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4760       };
4761     } catch (Dali::DaliException e) {
4762       {
4763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4764       };
4765     } catch (...) {
4766       {
4767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4768       };
4769     }
4770   }
4771
4772   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4773   return jresult;
4774 }
4775
4776
4777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4778   void * jresult ;
4779   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4780   float arg2 ;
4781   Dali::Vector2 result;
4782
4783   arg1 = (Dali::Vector2 *)jarg1;
4784   arg2 = (float)jarg2;
4785   {
4786     try {
4787       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4788     } catch (std::out_of_range& e) {
4789       {
4790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4791       };
4792     } catch (std::exception& e) {
4793       {
4794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4795       };
4796     } catch (Dali::DaliException e) {
4797       {
4798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4799       };
4800     } catch (...) {
4801       {
4802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4803       };
4804     }
4805   }
4806
4807   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4808   return jresult;
4809 }
4810
4811
4812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4813   void * jresult ;
4814   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4815   Dali::Vector2 *arg2 = 0 ;
4816   Dali::Vector2 *result = 0 ;
4817
4818   arg1 = (Dali::Vector2 *)jarg1;
4819   arg2 = (Dali::Vector2 *)jarg2;
4820   if (!arg2) {
4821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4822     return 0;
4823   }
4824   {
4825     try {
4826       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4827     } catch (std::out_of_range& e) {
4828       {
4829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4830       };
4831     } catch (std::exception& e) {
4832       {
4833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4834       };
4835     } catch (Dali::DaliException e) {
4836       {
4837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4838       };
4839     } catch (...) {
4840       {
4841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4842       };
4843     }
4844   }
4845
4846   jresult = (void *)result;
4847   return jresult;
4848 }
4849
4850
4851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4852   void * jresult ;
4853   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4854   float arg2 ;
4855   Dali::Vector2 *result = 0 ;
4856
4857   arg1 = (Dali::Vector2 *)jarg1;
4858   arg2 = (float)jarg2;
4859   {
4860     try {
4861       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4862     } catch (std::out_of_range& e) {
4863       {
4864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4865       };
4866     } catch (std::exception& e) {
4867       {
4868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4869       };
4870     } catch (Dali::DaliException e) {
4871       {
4872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4873       };
4874     } catch (...) {
4875       {
4876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4877       };
4878     }
4879   }
4880
4881   jresult = (void *)result;
4882   return jresult;
4883 }
4884
4885
4886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4887   void * jresult ;
4888   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4889   Dali::Vector2 result;
4890
4891   arg1 = (Dali::Vector2 *)jarg1;
4892   {
4893     try {
4894       result = ((Dali::Vector2 const *)arg1)->operator -();
4895     } catch (std::out_of_range& e) {
4896       {
4897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (std::exception& e) {
4900       {
4901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4902       };
4903     } catch (Dali::DaliException e) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4906       };
4907     } catch (...) {
4908       {
4909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4910       };
4911     }
4912   }
4913
4914   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4915   return jresult;
4916 }
4917
4918
4919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4920   unsigned int jresult ;
4921   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4922   Dali::Vector2 *arg2 = 0 ;
4923   bool result;
4924
4925   arg1 = (Dali::Vector2 *)jarg1;
4926   arg2 = (Dali::Vector2 *)jarg2;
4927   if (!arg2) {
4928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4929     return 0;
4930   }
4931   {
4932     try {
4933       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4941       };
4942     } catch (Dali::DaliException e) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4945       };
4946     } catch (...) {
4947       {
4948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4949       };
4950     }
4951   }
4952
4953   jresult = result;
4954   return jresult;
4955 }
4956
4957
4958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4959   unsigned int jresult ;
4960   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4961   Dali::Vector2 *arg2 = 0 ;
4962   bool result;
4963
4964   arg1 = (Dali::Vector2 *)jarg1;
4965   arg2 = (Dali::Vector2 *)jarg2;
4966   if (!arg2) {
4967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4968     return 0;
4969   }
4970   {
4971     try {
4972       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4973     } catch (std::out_of_range& e) {
4974       {
4975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4976       };
4977     } catch (std::exception& e) {
4978       {
4979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4980       };
4981     } catch (Dali::DaliException e) {
4982       {
4983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4984       };
4985     } catch (...) {
4986       {
4987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4988       };
4989     }
4990   }
4991
4992   jresult = result;
4993   return jresult;
4994 }
4995
4996
4997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4998   float jresult ;
4999   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5000   unsigned int arg2 ;
5001   float *result = 0 ;
5002
5003   arg1 = (Dali::Vector2 *)jarg1;
5004   arg2 = (unsigned int)jarg2;
5005   {
5006     try {
5007       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5008     } catch (std::out_of_range& e) {
5009       {
5010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5011       };
5012     } catch (std::exception& e) {
5013       {
5014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5015       };
5016     } catch (Dali::DaliException e) {
5017       {
5018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5019       };
5020     } catch (...) {
5021       {
5022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5023       };
5024     }
5025   }
5026
5027   jresult = *result;
5028   return jresult;
5029 }
5030
5031
5032 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5033   float jresult ;
5034   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5035   float result;
5036
5037   arg1 = (Dali::Vector2 *)jarg1;
5038   {
5039     try {
5040       result = (float)((Dali::Vector2 const *)arg1)->Length();
5041     } catch (std::out_of_range& e) {
5042       {
5043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5044       };
5045     } catch (std::exception& e) {
5046       {
5047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5048       };
5049     } catch (Dali::DaliException e) {
5050       {
5051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5052       };
5053     } catch (...) {
5054       {
5055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5056       };
5057     }
5058   }
5059
5060   jresult = result;
5061   return jresult;
5062 }
5063
5064
5065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5066   float jresult ;
5067   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5068   float result;
5069
5070   arg1 = (Dali::Vector2 *)jarg1;
5071   {
5072     try {
5073       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5100
5101   arg1 = (Dali::Vector2 *)jarg1;
5102   {
5103     try {
5104       (arg1)->Normalize();
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5112       };
5113     } catch (Dali::DaliException e) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5116       };
5117     } catch (...) {
5118       {
5119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5120       };
5121     }
5122   }
5123
5124 }
5125
5126
5127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5128   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5129   Dali::Vector2 *arg2 = 0 ;
5130   Dali::Vector2 *arg3 = 0 ;
5131
5132   arg1 = (Dali::Vector2 *)jarg1;
5133   arg2 = (Dali::Vector2 *)jarg2;
5134   if (!arg2) {
5135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5136     return ;
5137   }
5138   arg3 = (Dali::Vector2 *)jarg3;
5139   if (!arg3) {
5140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5141     return ;
5142   }
5143   {
5144     try {
5145       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5146     } catch (std::out_of_range& e) {
5147       {
5148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5149       };
5150     } catch (std::exception& e) {
5151       {
5152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5153       };
5154     } catch (Dali::DaliException e) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5161       };
5162     }
5163   }
5164
5165 }
5166
5167
5168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5169   void * jresult ;
5170   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5171   float *result = 0 ;
5172
5173   arg1 = (Dali::Vector2 *)jarg1;
5174   {
5175     try {
5176       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5177     } catch (std::out_of_range& e) {
5178       {
5179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5180       };
5181     } catch (std::exception& e) {
5182       {
5183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (Dali::DaliException e) {
5186       {
5187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5188       };
5189     } catch (...) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5192       };
5193     }
5194   }
5195
5196   jresult = (void *)result;
5197   return jresult;
5198 }
5199
5200
5201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5202   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5203   float arg2 ;
5204
5205   arg1 = (Dali::Vector2 *)jarg1;
5206   arg2 = (float)jarg2;
5207   if (arg1) (arg1)->x = arg2;
5208 }
5209
5210
5211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5212   float jresult ;
5213   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5214   float result;
5215
5216   arg1 = (Dali::Vector2 *)jarg1;
5217   result = (float) ((arg1)->x);
5218   jresult = result;
5219   return jresult;
5220 }
5221
5222
5223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5224   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5225   float arg2 ;
5226
5227   arg1 = (Dali::Vector2 *)jarg1;
5228   arg2 = (float)jarg2;
5229   if (arg1) (arg1)->width = arg2;
5230 }
5231
5232
5233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5234   float jresult ;
5235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5236   float result;
5237
5238   arg1 = (Dali::Vector2 *)jarg1;
5239   result = (float) ((arg1)->width);
5240   jresult = result;
5241   return jresult;
5242 }
5243
5244
5245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5246   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5247   float arg2 ;
5248
5249   arg1 = (Dali::Vector2 *)jarg1;
5250   arg2 = (float)jarg2;
5251   if (arg1) (arg1)->y = arg2;
5252 }
5253
5254
5255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5256   float jresult ;
5257   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5258   float result;
5259
5260   arg1 = (Dali::Vector2 *)jarg1;
5261   result = (float) ((arg1)->y);
5262   jresult = result;
5263   return jresult;
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   float arg2 ;
5270
5271   arg1 = (Dali::Vector2 *)jarg1;
5272   arg2 = (float)jarg2;
5273   if (arg1) (arg1)->height = arg2;
5274 }
5275
5276
5277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5278   float jresult ;
5279   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5280   float result;
5281
5282   arg1 = (Dali::Vector2 *)jarg1;
5283   result = (float) ((arg1)->height);
5284   jresult = result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5290   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5291
5292   arg1 = (Dali::Vector2 *)jarg1;
5293   {
5294     try {
5295       delete arg1;
5296     } catch (std::out_of_range& e) {
5297       {
5298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5299       };
5300     } catch (std::exception& e) {
5301       {
5302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5303       };
5304     } catch (Dali::DaliException e) {
5305       {
5306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5307       };
5308     } catch (...) {
5309       {
5310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5311       };
5312     }
5313   }
5314
5315 }
5316
5317
5318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5319   void * jresult ;
5320   Dali::Vector2 *arg1 = 0 ;
5321   Dali::Vector2 *arg2 = 0 ;
5322   Dali::Vector2 result;
5323
5324   arg1 = (Dali::Vector2 *)jarg1;
5325   if (!arg1) {
5326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5327     return 0;
5328   }
5329   arg2 = (Dali::Vector2 *)jarg2;
5330   if (!arg2) {
5331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5332     return 0;
5333   }
5334   {
5335     try {
5336       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5337     } catch (std::out_of_range& e) {
5338       {
5339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5340       };
5341     } catch (std::exception& e) {
5342       {
5343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5344       };
5345     } catch (Dali::DaliException e) {
5346       {
5347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5348       };
5349     } catch (...) {
5350       {
5351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5352       };
5353     }
5354   }
5355
5356   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5362   void * jresult ;
5363   Dali::Vector2 *arg1 = 0 ;
5364   Dali::Vector2 *arg2 = 0 ;
5365   Dali::Vector2 result;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   if (!arg1) {
5369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5370     return 0;
5371   }
5372   arg2 = (Dali::Vector2 *)jarg2;
5373   if (!arg2) {
5374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5375     return 0;
5376   }
5377   {
5378     try {
5379       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5380     } catch (std::out_of_range& e) {
5381       {
5382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5383       };
5384     } catch (std::exception& e) {
5385       {
5386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5387       };
5388     } catch (Dali::DaliException e) {
5389       {
5390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5391       };
5392     } catch (...) {
5393       {
5394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5395       };
5396     }
5397   }
5398
5399   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5405   void * jresult ;
5406   Dali::Vector2 *arg1 = 0 ;
5407   float *arg2 = 0 ;
5408   float *arg3 = 0 ;
5409   float temp2 ;
5410   float temp3 ;
5411   Dali::Vector2 result;
5412
5413   arg1 = (Dali::Vector2 *)jarg1;
5414   if (!arg1) {
5415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5416     return 0;
5417   }
5418   temp2 = (float)jarg2;
5419   arg2 = &temp2;
5420   temp3 = (float)jarg3;
5421   arg3 = &temp3;
5422   {
5423     try {
5424       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5425     } catch (std::out_of_range& e) {
5426       {
5427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5428       };
5429     } catch (std::exception& e) {
5430       {
5431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5432       };
5433     } catch (Dali::DaliException e) {
5434       {
5435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5436       };
5437     } catch (...) {
5438       {
5439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5440       };
5441     }
5442   }
5443
5444   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5445   return jresult;
5446 }
5447
5448
5449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5450   void * jresult ;
5451   Dali::Vector3 *result = 0 ;
5452
5453   {
5454     try {
5455       result = (Dali::Vector3 *)new Dali::Vector3();
5456     } catch (std::out_of_range& e) {
5457       {
5458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5459       };
5460     } catch (std::exception& e) {
5461       {
5462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5463       };
5464     } catch (Dali::DaliException e) {
5465       {
5466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5467       };
5468     } catch (...) {
5469       {
5470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5471       };
5472     }
5473   }
5474
5475   jresult = (void *)result;
5476   return jresult;
5477 }
5478
5479
5480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5481   void * jresult ;
5482   float arg1 ;
5483   float arg2 ;
5484   float arg3 ;
5485   Dali::Vector3 *result = 0 ;
5486
5487   arg1 = (float)jarg1;
5488   arg2 = (float)jarg2;
5489   arg3 = (float)jarg3;
5490   {
5491     try {
5492       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5493     } catch (std::out_of_range& e) {
5494       {
5495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5496       };
5497     } catch (std::exception& e) {
5498       {
5499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5500       };
5501     } catch (Dali::DaliException e) {
5502       {
5503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5504       };
5505     } catch (...) {
5506       {
5507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5508       };
5509     }
5510   }
5511
5512   jresult = (void *)result;
5513   return jresult;
5514 }
5515
5516
5517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5518   void * jresult ;
5519   float *arg1 = (float *) 0 ;
5520   Dali::Vector3 *result = 0 ;
5521
5522   arg1 = jarg1;
5523   {
5524     try {
5525       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5526     } catch (std::out_of_range& e) {
5527       {
5528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5529       };
5530     } catch (std::exception& e) {
5531       {
5532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5533       };
5534     } catch (Dali::DaliException e) {
5535       {
5536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5537       };
5538     } catch (...) {
5539       {
5540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5541       };
5542     }
5543   }
5544
5545   jresult = (void *)result;
5546
5547
5548   return jresult;
5549 }
5550
5551
5552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5553   void * jresult ;
5554   Dali::Vector2 *arg1 = 0 ;
5555   Dali::Vector3 *result = 0 ;
5556
5557   arg1 = (Dali::Vector2 *)jarg1;
5558   if (!arg1) {
5559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5560     return 0;
5561   }
5562   {
5563     try {
5564       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = (void *)result;
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5590   void * jresult ;
5591   Dali::Vector4 *arg1 = 0 ;
5592   Dali::Vector3 *result = 0 ;
5593
5594   arg1 = (Dali::Vector4 *)jarg1;
5595   if (!arg1) {
5596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5597     return 0;
5598   }
5599   {
5600     try {
5601       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5602     } catch (std::out_of_range& e) {
5603       {
5604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5605       };
5606     } catch (std::exception& e) {
5607       {
5608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5609       };
5610     } catch (Dali::DaliException e) {
5611       {
5612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5613       };
5614     } catch (...) {
5615       {
5616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5617       };
5618     }
5619   }
5620
5621   jresult = (void *)result;
5622   return jresult;
5623 }
5624
5625
5626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5627   void * jresult ;
5628   Dali::Vector3 *result = 0 ;
5629
5630   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5631   jresult = (void *)result;
5632   return jresult;
5633 }
5634
5635
5636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5637   void * jresult ;
5638   Dali::Vector3 *result = 0 ;
5639
5640   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5641   jresult = (void *)result;
5642   return jresult;
5643 }
5644
5645
5646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5647   void * jresult ;
5648   Dali::Vector3 *result = 0 ;
5649
5650   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5651   jresult = (void *)result;
5652   return jresult;
5653 }
5654
5655
5656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5657   void * jresult ;
5658   Dali::Vector3 *result = 0 ;
5659
5660   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5661   jresult = (void *)result;
5662   return jresult;
5663 }
5664
5665
5666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5667   void * jresult ;
5668   Dali::Vector3 *result = 0 ;
5669
5670   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5671   jresult = (void *)result;
5672   return jresult;
5673 }
5674
5675
5676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5677   void * jresult ;
5678   Dali::Vector3 *result = 0 ;
5679
5680   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5681   jresult = (void *)result;
5682   return jresult;
5683 }
5684
5685
5686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5687   void * jresult ;
5688   Dali::Vector3 *result = 0 ;
5689
5690   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5691   jresult = (void *)result;
5692   return jresult;
5693 }
5694
5695
5696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5697   void * jresult ;
5698   Dali::Vector3 *result = 0 ;
5699
5700   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5701   jresult = (void *)result;
5702   return jresult;
5703 }
5704
5705
5706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5707   void * jresult ;
5708   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5709   float *arg2 = (float *) 0 ;
5710   Dali::Vector3 *result = 0 ;
5711
5712   arg1 = (Dali::Vector3 *)jarg1;
5713   arg2 = jarg2;
5714   {
5715     try {
5716       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5717     } catch (std::out_of_range& e) {
5718       {
5719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5720       };
5721     } catch (std::exception& e) {
5722       {
5723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5724       };
5725     } catch (Dali::DaliException e) {
5726       {
5727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5728       };
5729     } catch (...) {
5730       {
5731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5732       };
5733     }
5734   }
5735
5736   jresult = (void *)result;
5737
5738
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5744   void * jresult ;
5745   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5746   Dali::Vector2 *arg2 = 0 ;
5747   Dali::Vector3 *result = 0 ;
5748
5749   arg1 = (Dali::Vector3 *)jarg1;
5750   arg2 = (Dali::Vector2 *)jarg2;
5751   if (!arg2) {
5752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5753     return 0;
5754   }
5755   {
5756     try {
5757       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5758     } catch (std::out_of_range& e) {
5759       {
5760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5761       };
5762     } catch (std::exception& e) {
5763       {
5764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5765       };
5766     } catch (Dali::DaliException e) {
5767       {
5768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5769       };
5770     } catch (...) {
5771       {
5772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5773       };
5774     }
5775   }
5776
5777   jresult = (void *)result;
5778   return jresult;
5779 }
5780
5781
5782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5783   void * jresult ;
5784   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5785   Dali::Vector4 *arg2 = 0 ;
5786   Dali::Vector3 *result = 0 ;
5787
5788   arg1 = (Dali::Vector3 *)jarg1;
5789   arg2 = (Dali::Vector4 *)jarg2;
5790   if (!arg2) {
5791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5792     return 0;
5793   }
5794   {
5795     try {
5796       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5797     } catch (std::out_of_range& e) {
5798       {
5799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5800       };
5801     } catch (std::exception& e) {
5802       {
5803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5804       };
5805     } catch (Dali::DaliException e) {
5806       {
5807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5808       };
5809     } catch (...) {
5810       {
5811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5812       };
5813     }
5814   }
5815
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5822   void * jresult ;
5823   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5824   Dali::Vector3 *arg2 = 0 ;
5825   Dali::Vector3 result;
5826
5827   arg1 = (Dali::Vector3 *)jarg1;
5828   arg2 = (Dali::Vector3 *)jarg2;
5829   if (!arg2) {
5830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5831     return 0;
5832   }
5833   {
5834     try {
5835       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5836     } catch (std::out_of_range& e) {
5837       {
5838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5839       };
5840     } catch (std::exception& e) {
5841       {
5842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5843       };
5844     } catch (Dali::DaliException e) {
5845       {
5846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5847       };
5848     } catch (...) {
5849       {
5850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5851       };
5852     }
5853   }
5854
5855   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5856   return jresult;
5857 }
5858
5859
5860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5861   void * jresult ;
5862   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5863   Dali::Vector3 *arg2 = 0 ;
5864   Dali::Vector3 *result = 0 ;
5865
5866   arg1 = (Dali::Vector3 *)jarg1;
5867   arg2 = (Dali::Vector3 *)jarg2;
5868   if (!arg2) {
5869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5870     return 0;
5871   }
5872   {
5873     try {
5874       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5875     } catch (std::out_of_range& e) {
5876       {
5877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5878       };
5879     } catch (std::exception& e) {
5880       {
5881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5882       };
5883     } catch (Dali::DaliException e) {
5884       {
5885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5886       };
5887     } catch (...) {
5888       {
5889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5890       };
5891     }
5892   }
5893
5894   jresult = (void *)result;
5895   return jresult;
5896 }
5897
5898
5899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5900   void * jresult ;
5901   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5902   Dali::Vector3 *arg2 = 0 ;
5903   Dali::Vector3 result;
5904
5905   arg1 = (Dali::Vector3 *)jarg1;
5906   arg2 = (Dali::Vector3 *)jarg2;
5907   if (!arg2) {
5908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5909     return 0;
5910   }
5911   {
5912     try {
5913       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5914     } catch (std::out_of_range& e) {
5915       {
5916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5917       };
5918     } catch (std::exception& e) {
5919       {
5920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5921       };
5922     } catch (Dali::DaliException e) {
5923       {
5924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5925       };
5926     } catch (...) {
5927       {
5928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5929       };
5930     }
5931   }
5932
5933   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5934   return jresult;
5935 }
5936
5937
5938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5939   void * jresult ;
5940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5941   Dali::Vector3 *arg2 = 0 ;
5942   Dali::Vector3 *result = 0 ;
5943
5944   arg1 = (Dali::Vector3 *)jarg1;
5945   arg2 = (Dali::Vector3 *)jarg2;
5946   if (!arg2) {
5947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5948     return 0;
5949   }
5950   {
5951     try {
5952       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5953     } catch (std::out_of_range& e) {
5954       {
5955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5956       };
5957     } catch (std::exception& e) {
5958       {
5959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5960       };
5961     } catch (Dali::DaliException e) {
5962       {
5963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5964       };
5965     } catch (...) {
5966       {
5967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5968       };
5969     }
5970   }
5971
5972   jresult = (void *)result;
5973   return jresult;
5974 }
5975
5976
5977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5978   void * jresult ;
5979   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5980   Dali::Vector3 *arg2 = 0 ;
5981   Dali::Vector3 result;
5982
5983   arg1 = (Dali::Vector3 *)jarg1;
5984   arg2 = (Dali::Vector3 *)jarg2;
5985   if (!arg2) {
5986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5987     return 0;
5988   }
5989   {
5990     try {
5991       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5992     } catch (std::out_of_range& e) {
5993       {
5994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5995       };
5996     } catch (std::exception& e) {
5997       {
5998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5999       };
6000     } catch (Dali::DaliException e) {
6001       {
6002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6003       };
6004     } catch (...) {
6005       {
6006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6007       };
6008     }
6009   }
6010
6011   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6012   return jresult;
6013 }
6014
6015
6016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6017   void * jresult ;
6018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6019   float arg2 ;
6020   Dali::Vector3 result;
6021
6022   arg1 = (Dali::Vector3 *)jarg1;
6023   arg2 = (float)jarg2;
6024   {
6025     try {
6026       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6027     } catch (std::out_of_range& e) {
6028       {
6029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6030       };
6031     } catch (std::exception& e) {
6032       {
6033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6034       };
6035     } catch (Dali::DaliException e) {
6036       {
6037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6038       };
6039     } catch (...) {
6040       {
6041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6042       };
6043     }
6044   }
6045
6046   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6047   return jresult;
6048 }
6049
6050
6051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6052   void * jresult ;
6053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6054   Dali::Vector3 *arg2 = 0 ;
6055   Dali::Vector3 *result = 0 ;
6056
6057   arg1 = (Dali::Vector3 *)jarg1;
6058   arg2 = (Dali::Vector3 *)jarg2;
6059   if (!arg2) {
6060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6061     return 0;
6062   }
6063   {
6064     try {
6065       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6066     } catch (std::out_of_range& e) {
6067       {
6068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6069       };
6070     } catch (std::exception& e) {
6071       {
6072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6073       };
6074     } catch (Dali::DaliException e) {
6075       {
6076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6077       };
6078     } catch (...) {
6079       {
6080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6081       };
6082     }
6083   }
6084
6085   jresult = (void *)result;
6086   return jresult;
6087 }
6088
6089
6090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6091   void * jresult ;
6092   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6093   float arg2 ;
6094   Dali::Vector3 *result = 0 ;
6095
6096   arg1 = (Dali::Vector3 *)jarg1;
6097   arg2 = (float)jarg2;
6098   {
6099     try {
6100       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6101     } catch (std::out_of_range& e) {
6102       {
6103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6104       };
6105     } catch (std::exception& e) {
6106       {
6107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6108       };
6109     } catch (Dali::DaliException e) {
6110       {
6111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6112       };
6113     } catch (...) {
6114       {
6115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6116       };
6117     }
6118   }
6119
6120   jresult = (void *)result;
6121   return jresult;
6122 }
6123
6124
6125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6126   void * jresult ;
6127   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6128   Dali::Quaternion *arg2 = 0 ;
6129   Dali::Vector3 *result = 0 ;
6130
6131   arg1 = (Dali::Vector3 *)jarg1;
6132   arg2 = (Dali::Quaternion *)jarg2;
6133   if (!arg2) {
6134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6135     return 0;
6136   }
6137   {
6138     try {
6139       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6140     } catch (std::out_of_range& e) {
6141       {
6142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6143       };
6144     } catch (std::exception& e) {
6145       {
6146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6147       };
6148     } catch (Dali::DaliException e) {
6149       {
6150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6151       };
6152     } catch (...) {
6153       {
6154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6155       };
6156     }
6157   }
6158
6159   jresult = (void *)result;
6160   return jresult;
6161 }
6162
6163
6164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6165   void * jresult ;
6166   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6167   Dali::Vector3 *arg2 = 0 ;
6168   Dali::Vector3 result;
6169
6170   arg1 = (Dali::Vector3 *)jarg1;
6171   arg2 = (Dali::Vector3 *)jarg2;
6172   if (!arg2) {
6173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6174     return 0;
6175   }
6176   {
6177     try {
6178       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6179     } catch (std::out_of_range& e) {
6180       {
6181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6182       };
6183     } catch (std::exception& e) {
6184       {
6185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6186       };
6187     } catch (Dali::DaliException e) {
6188       {
6189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6190       };
6191     } catch (...) {
6192       {
6193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6194       };
6195     }
6196   }
6197
6198   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6199   return jresult;
6200 }
6201
6202
6203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6204   void * jresult ;
6205   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6206   float arg2 ;
6207   Dali::Vector3 result;
6208
6209   arg1 = (Dali::Vector3 *)jarg1;
6210   arg2 = (float)jarg2;
6211   {
6212     try {
6213       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6214     } catch (std::out_of_range& e) {
6215       {
6216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6217       };
6218     } catch (std::exception& e) {
6219       {
6220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6221       };
6222     } catch (Dali::DaliException e) {
6223       {
6224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6225       };
6226     } catch (...) {
6227       {
6228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6229       };
6230     }
6231   }
6232
6233   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6234   return jresult;
6235 }
6236
6237
6238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6239   void * jresult ;
6240   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6241   Dali::Vector3 *arg2 = 0 ;
6242   Dali::Vector3 *result = 0 ;
6243
6244   arg1 = (Dali::Vector3 *)jarg1;
6245   arg2 = (Dali::Vector3 *)jarg2;
6246   if (!arg2) {
6247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6248     return 0;
6249   }
6250   {
6251     try {
6252       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6253     } catch (std::out_of_range& e) {
6254       {
6255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6256       };
6257     } catch (std::exception& e) {
6258       {
6259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6260       };
6261     } catch (Dali::DaliException e) {
6262       {
6263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6264       };
6265     } catch (...) {
6266       {
6267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6268       };
6269     }
6270   }
6271
6272   jresult = (void *)result;
6273   return jresult;
6274 }
6275
6276
6277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6278   void * jresult ;
6279   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6280   float arg2 ;
6281   Dali::Vector3 *result = 0 ;
6282
6283   arg1 = (Dali::Vector3 *)jarg1;
6284   arg2 = (float)jarg2;
6285   {
6286     try {
6287       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6288     } catch (std::out_of_range& e) {
6289       {
6290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6291       };
6292     } catch (std::exception& e) {
6293       {
6294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6295       };
6296     } catch (Dali::DaliException e) {
6297       {
6298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6299       };
6300     } catch (...) {
6301       {
6302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6303       };
6304     }
6305   }
6306
6307   jresult = (void *)result;
6308   return jresult;
6309 }
6310
6311
6312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6313   void * jresult ;
6314   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6315   Dali::Vector3 result;
6316
6317   arg1 = (Dali::Vector3 *)jarg1;
6318   {
6319     try {
6320       result = ((Dali::Vector3 const *)arg1)->operator -();
6321     } catch (std::out_of_range& e) {
6322       {
6323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (std::exception& e) {
6326       {
6327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6328       };
6329     } catch (Dali::DaliException e) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6332       };
6333     } catch (...) {
6334       {
6335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6336       };
6337     }
6338   }
6339
6340   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6341   return jresult;
6342 }
6343
6344
6345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6346   unsigned int jresult ;
6347   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6348   Dali::Vector3 *arg2 = 0 ;
6349   bool result;
6350
6351   arg1 = (Dali::Vector3 *)jarg1;
6352   arg2 = (Dali::Vector3 *)jarg2;
6353   if (!arg2) {
6354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6355     return 0;
6356   }
6357   {
6358     try {
6359       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6360     } catch (std::out_of_range& e) {
6361       {
6362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6363       };
6364     } catch (std::exception& e) {
6365       {
6366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6367       };
6368     } catch (Dali::DaliException e) {
6369       {
6370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6371       };
6372     } catch (...) {
6373       {
6374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6375       };
6376     }
6377   }
6378
6379   jresult = result;
6380   return jresult;
6381 }
6382
6383
6384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6385   unsigned int jresult ;
6386   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6387   Dali::Vector3 *arg2 = 0 ;
6388   bool result;
6389
6390   arg1 = (Dali::Vector3 *)jarg1;
6391   arg2 = (Dali::Vector3 *)jarg2;
6392   if (!arg2) {
6393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6394     return 0;
6395   }
6396   {
6397     try {
6398       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6399     } catch (std::out_of_range& e) {
6400       {
6401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6402       };
6403     } catch (std::exception& e) {
6404       {
6405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6406       };
6407     } catch (Dali::DaliException e) {
6408       {
6409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6410       };
6411     } catch (...) {
6412       {
6413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6414       };
6415     }
6416   }
6417
6418   jresult = result;
6419   return jresult;
6420 }
6421
6422
6423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6424   float jresult ;
6425   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6426   unsigned int arg2 ;
6427   float *result = 0 ;
6428
6429   arg1 = (Dali::Vector3 *)jarg1;
6430   arg2 = (unsigned int)jarg2;
6431   {
6432     try {
6433       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6434     } catch (std::out_of_range& e) {
6435       {
6436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6437       };
6438     } catch (std::exception& e) {
6439       {
6440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6441       };
6442     } catch (Dali::DaliException e) {
6443       {
6444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6445       };
6446     } catch (...) {
6447       {
6448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6449       };
6450     }
6451   }
6452
6453   jresult = *result;
6454   return jresult;
6455 }
6456
6457
6458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6459   float jresult ;
6460   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6461   Dali::Vector3 *arg2 = 0 ;
6462   float result;
6463
6464   arg1 = (Dali::Vector3 *)jarg1;
6465   arg2 = (Dali::Vector3 *)jarg2;
6466   if (!arg2) {
6467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6468     return 0;
6469   }
6470   {
6471     try {
6472       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6473     } catch (std::out_of_range& e) {
6474       {
6475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6476       };
6477     } catch (std::exception& e) {
6478       {
6479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6480       };
6481     } catch (Dali::DaliException e) {
6482       {
6483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6484       };
6485     } catch (...) {
6486       {
6487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6488       };
6489     }
6490   }
6491
6492   jresult = result;
6493   return jresult;
6494 }
6495
6496
6497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6498   void * jresult ;
6499   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6500   Dali::Vector3 *arg2 = 0 ;
6501   Dali::Vector3 result;
6502
6503   arg1 = (Dali::Vector3 *)jarg1;
6504   arg2 = (Dali::Vector3 *)jarg2;
6505   if (!arg2) {
6506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6507     return 0;
6508   }
6509   {
6510     try {
6511       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6512     } catch (std::out_of_range& e) {
6513       {
6514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6515       };
6516     } catch (std::exception& e) {
6517       {
6518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6519       };
6520     } catch (Dali::DaliException e) {
6521       {
6522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6523       };
6524     } catch (...) {
6525       {
6526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6527       };
6528     }
6529   }
6530
6531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6532   return jresult;
6533 }
6534
6535
6536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6537   float jresult ;
6538   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6539   float result;
6540
6541   arg1 = (Dali::Vector3 *)jarg1;
6542   {
6543     try {
6544       result = (float)((Dali::Vector3 const *)arg1)->Length();
6545     } catch (std::out_of_range& e) {
6546       {
6547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6548       };
6549     } catch (std::exception& e) {
6550       {
6551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6552       };
6553     } catch (Dali::DaliException e) {
6554       {
6555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6556       };
6557     } catch (...) {
6558       {
6559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6560       };
6561     }
6562   }
6563
6564   jresult = result;
6565   return jresult;
6566 }
6567
6568
6569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6570   float jresult ;
6571   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6572   float result;
6573
6574   arg1 = (Dali::Vector3 *)jarg1;
6575   {
6576     try {
6577       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6578     } catch (std::out_of_range& e) {
6579       {
6580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (std::exception& e) {
6583       {
6584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6585       };
6586     } catch (Dali::DaliException e) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6589       };
6590     } catch (...) {
6591       {
6592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6593       };
6594     }
6595   }
6596
6597   jresult = result;
6598   return jresult;
6599 }
6600
6601
6602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6603   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6604
6605   arg1 = (Dali::Vector3 *)jarg1;
6606   {
6607     try {
6608       (arg1)->Normalize();
6609     } catch (std::out_of_range& e) {
6610       {
6611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6612       };
6613     } catch (std::exception& e) {
6614       {
6615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6616       };
6617     } catch (Dali::DaliException e) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6620       };
6621     } catch (...) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6624       };
6625     }
6626   }
6627
6628 }
6629
6630
6631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6632   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6633   Dali::Vector3 *arg2 = 0 ;
6634   Dali::Vector3 *arg3 = 0 ;
6635
6636   arg1 = (Dali::Vector3 *)jarg1;
6637   arg2 = (Dali::Vector3 *)jarg2;
6638   if (!arg2) {
6639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6640     return ;
6641   }
6642   arg3 = (Dali::Vector3 *)jarg3;
6643   if (!arg3) {
6644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6645     return ;
6646   }
6647   {
6648     try {
6649       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6650     } catch (std::out_of_range& e) {
6651       {
6652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6653       };
6654     } catch (std::exception& e) {
6655       {
6656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6657       };
6658     } catch (Dali::DaliException e) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6661       };
6662     } catch (...) {
6663       {
6664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6665       };
6666     }
6667   }
6668
6669 }
6670
6671
6672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6673   void * jresult ;
6674   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6675   float *result = 0 ;
6676
6677   arg1 = (Dali::Vector3 *)jarg1;
6678   {
6679     try {
6680       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6681     } catch (std::out_of_range& e) {
6682       {
6683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (std::exception& e) {
6686       {
6687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (Dali::DaliException e) {
6690       {
6691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6692       };
6693     } catch (...) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6696       };
6697     }
6698   }
6699
6700   jresult = (void *)result;
6701   return jresult;
6702 }
6703
6704
6705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6706   void * jresult ;
6707   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6708   Dali::Vector2 *result = 0 ;
6709
6710   arg1 = (Dali::Vector3 *)jarg1;
6711   {
6712     try {
6713       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6714     } catch (std::out_of_range& e) {
6715       {
6716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (std::exception& e) {
6719       {
6720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (Dali::DaliException e) {
6723       {
6724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6725       };
6726     } catch (...) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6729       };
6730     }
6731   }
6732
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6739   void * jresult ;
6740   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6741   Dali::Vector2 *result = 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   {
6745     try {
6746       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6754       };
6755     } catch (Dali::DaliException e) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6758       };
6759     } catch (...) {
6760       {
6761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6762       };
6763     }
6764   }
6765
6766   jresult = (void *)result;
6767   return jresult;
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   float arg2 ;
6774
6775   arg1 = (Dali::Vector3 *)jarg1;
6776   arg2 = (float)jarg2;
6777   if (arg1) (arg1)->x = arg2;
6778 }
6779
6780
6781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6782   float jresult ;
6783   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6784   float result;
6785
6786   arg1 = (Dali::Vector3 *)jarg1;
6787   result = (float) ((arg1)->x);
6788   jresult = result;
6789   return jresult;
6790 }
6791
6792
6793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6795   float arg2 ;
6796
6797   arg1 = (Dali::Vector3 *)jarg1;
6798   arg2 = (float)jarg2;
6799   if (arg1) (arg1)->width = arg2;
6800 }
6801
6802
6803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6804   float jresult ;
6805   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6806   float result;
6807
6808   arg1 = (Dali::Vector3 *)jarg1;
6809   result = (float) ((arg1)->width);
6810   jresult = result;
6811   return jresult;
6812 }
6813
6814
6815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6816   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6817   float arg2 ;
6818
6819   arg1 = (Dali::Vector3 *)jarg1;
6820   arg2 = (float)jarg2;
6821   if (arg1) (arg1)->r = arg2;
6822 }
6823
6824
6825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6826   float jresult ;
6827   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6828   float result;
6829
6830   arg1 = (Dali::Vector3 *)jarg1;
6831   result = (float) ((arg1)->r);
6832   jresult = result;
6833   return jresult;
6834 }
6835
6836
6837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6838   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6839   float arg2 ;
6840
6841   arg1 = (Dali::Vector3 *)jarg1;
6842   arg2 = (float)jarg2;
6843   if (arg1) (arg1)->y = arg2;
6844 }
6845
6846
6847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6848   float jresult ;
6849   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6850   float result;
6851
6852   arg1 = (Dali::Vector3 *)jarg1;
6853   result = (float) ((arg1)->y);
6854   jresult = result;
6855   return jresult;
6856 }
6857
6858
6859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6860   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6861   float arg2 ;
6862
6863   arg1 = (Dali::Vector3 *)jarg1;
6864   arg2 = (float)jarg2;
6865   if (arg1) (arg1)->height = arg2;
6866 }
6867
6868
6869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6870   float jresult ;
6871   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6872   float result;
6873
6874   arg1 = (Dali::Vector3 *)jarg1;
6875   result = (float) ((arg1)->height);
6876   jresult = result;
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6883   float arg2 ;
6884
6885   arg1 = (Dali::Vector3 *)jarg1;
6886   arg2 = (float)jarg2;
6887   if (arg1) (arg1)->g = arg2;
6888 }
6889
6890
6891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6892   float jresult ;
6893   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6894   float result;
6895
6896   arg1 = (Dali::Vector3 *)jarg1;
6897   result = (float) ((arg1)->g);
6898   jresult = result;
6899   return jresult;
6900 }
6901
6902
6903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6905   float arg2 ;
6906
6907   arg1 = (Dali::Vector3 *)jarg1;
6908   arg2 = (float)jarg2;
6909   if (arg1) (arg1)->z = arg2;
6910 }
6911
6912
6913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6914   float jresult ;
6915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6916   float result;
6917
6918   arg1 = (Dali::Vector3 *)jarg1;
6919   result = (float) ((arg1)->z);
6920   jresult = result;
6921   return jresult;
6922 }
6923
6924
6925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6927   float arg2 ;
6928
6929   arg1 = (Dali::Vector3 *)jarg1;
6930   arg2 = (float)jarg2;
6931   if (arg1) (arg1)->depth = arg2;
6932 }
6933
6934
6935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6936   float jresult ;
6937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6938   float result;
6939
6940   arg1 = (Dali::Vector3 *)jarg1;
6941   result = (float) ((arg1)->depth);
6942   jresult = result;
6943   return jresult;
6944 }
6945
6946
6947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6948   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6949   float arg2 ;
6950
6951   arg1 = (Dali::Vector3 *)jarg1;
6952   arg2 = (float)jarg2;
6953   if (arg1) (arg1)->b = arg2;
6954 }
6955
6956
6957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6958   float jresult ;
6959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6960   float result;
6961
6962   arg1 = (Dali::Vector3 *)jarg1;
6963   result = (float) ((arg1)->b);
6964   jresult = result;
6965   return jresult;
6966 }
6967
6968
6969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6970   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6971
6972   arg1 = (Dali::Vector3 *)jarg1;
6973   {
6974     try {
6975       delete arg1;
6976     } catch (std::out_of_range& e) {
6977       {
6978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6979       };
6980     } catch (std::exception& e) {
6981       {
6982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6983       };
6984     } catch (Dali::DaliException e) {
6985       {
6986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6987       };
6988     } catch (...) {
6989       {
6990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6991       };
6992     }
6993   }
6994
6995 }
6996
6997
6998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6999   void * jresult ;
7000   Dali::Vector3 *arg1 = 0 ;
7001   Dali::Vector3 *arg2 = 0 ;
7002   Dali::Vector3 result;
7003
7004   arg1 = (Dali::Vector3 *)jarg1;
7005   if (!arg1) {
7006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7007     return 0;
7008   }
7009   arg2 = (Dali::Vector3 *)jarg2;
7010   if (!arg2) {
7011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7012     return 0;
7013   }
7014   {
7015     try {
7016       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7017     } catch (std::out_of_range& e) {
7018       {
7019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7020       };
7021     } catch (std::exception& e) {
7022       {
7023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7024       };
7025     } catch (Dali::DaliException e) {
7026       {
7027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7028       };
7029     } catch (...) {
7030       {
7031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7032       };
7033     }
7034   }
7035
7036   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7042   void * jresult ;
7043   Dali::Vector3 *arg1 = 0 ;
7044   Dali::Vector3 *arg2 = 0 ;
7045   Dali::Vector3 result;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   if (!arg1) {
7049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7050     return 0;
7051   }
7052   arg2 = (Dali::Vector3 *)jarg2;
7053   if (!arg2) {
7054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7055     return 0;
7056   }
7057   {
7058     try {
7059       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7060     } catch (std::out_of_range& e) {
7061       {
7062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7063       };
7064     } catch (std::exception& e) {
7065       {
7066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7067       };
7068     } catch (Dali::DaliException e) {
7069       {
7070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7071       };
7072     } catch (...) {
7073       {
7074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7075       };
7076     }
7077   }
7078
7079   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7080   return jresult;
7081 }
7082
7083
7084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7085   void * jresult ;
7086   Dali::Vector3 *arg1 = 0 ;
7087   float *arg2 = 0 ;
7088   float *arg3 = 0 ;
7089   float temp2 ;
7090   float temp3 ;
7091   Dali::Vector3 result;
7092
7093   arg1 = (Dali::Vector3 *)jarg1;
7094   if (!arg1) {
7095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7096     return 0;
7097   }
7098   temp2 = (float)jarg2;
7099   arg2 = &temp2;
7100   temp3 = (float)jarg3;
7101   arg3 = &temp3;
7102   {
7103     try {
7104       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7105     } catch (std::out_of_range& e) {
7106       {
7107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7108       };
7109     } catch (std::exception& e) {
7110       {
7111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7112       };
7113     } catch (Dali::DaliException e) {
7114       {
7115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7116       };
7117     } catch (...) {
7118       {
7119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7120       };
7121     }
7122   }
7123
7124   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7125   return jresult;
7126 }
7127
7128
7129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7130   void * jresult ;
7131   Dali::Vector4 *result = 0 ;
7132
7133   {
7134     try {
7135       result = (Dali::Vector4 *)new Dali::Vector4();
7136     } catch (std::out_of_range& e) {
7137       {
7138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7139       };
7140     } catch (std::exception& e) {
7141       {
7142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7143       };
7144     } catch (Dali::DaliException e) {
7145       {
7146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7147       };
7148     } catch (...) {
7149       {
7150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7151       };
7152     }
7153   }
7154
7155   jresult = (void *)result;
7156   return jresult;
7157 }
7158
7159
7160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7161   void * jresult ;
7162   float arg1 ;
7163   float arg2 ;
7164   float arg3 ;
7165   float arg4 ;
7166   Dali::Vector4 *result = 0 ;
7167
7168   arg1 = (float)jarg1;
7169   arg2 = (float)jarg2;
7170   arg3 = (float)jarg3;
7171   arg4 = (float)jarg4;
7172   {
7173     try {
7174       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7175     } catch (std::out_of_range& e) {
7176       {
7177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7178       };
7179     } catch (std::exception& e) {
7180       {
7181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7182       };
7183     } catch (Dali::DaliException e) {
7184       {
7185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7186       };
7187     } catch (...) {
7188       {
7189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7190       };
7191     }
7192   }
7193
7194   jresult = (void *)result;
7195   return jresult;
7196 }
7197
7198
7199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7200   void * jresult ;
7201   float *arg1 = (float *) 0 ;
7202   Dali::Vector4 *result = 0 ;
7203
7204   arg1 = jarg1;
7205   {
7206     try {
7207       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7208     } catch (std::out_of_range& e) {
7209       {
7210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7211       };
7212     } catch (std::exception& e) {
7213       {
7214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7215       };
7216     } catch (Dali::DaliException e) {
7217       {
7218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7219       };
7220     } catch (...) {
7221       {
7222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7223       };
7224     }
7225   }
7226
7227   jresult = (void *)result;
7228
7229
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7235   void * jresult ;
7236   Dali::Vector2 *arg1 = 0 ;
7237   Dali::Vector4 *result = 0 ;
7238
7239   arg1 = (Dali::Vector2 *)jarg1;
7240   if (!arg1) {
7241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7242     return 0;
7243   }
7244   {
7245     try {
7246       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7247     } catch (std::out_of_range& e) {
7248       {
7249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (std::exception& e) {
7252       {
7253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7254       };
7255     } catch (Dali::DaliException e) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7258       };
7259     } catch (...) {
7260       {
7261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7262       };
7263     }
7264   }
7265
7266   jresult = (void *)result;
7267   return jresult;
7268 }
7269
7270
7271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7272   void * jresult ;
7273   Dali::Vector3 *arg1 = 0 ;
7274   Dali::Vector4 *result = 0 ;
7275
7276   arg1 = (Dali::Vector3 *)jarg1;
7277   if (!arg1) {
7278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7279     return 0;
7280   }
7281   {
7282     try {
7283       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7284     } catch (std::out_of_range& e) {
7285       {
7286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7287       };
7288     } catch (std::exception& e) {
7289       {
7290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7291       };
7292     } catch (Dali::DaliException e) {
7293       {
7294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7295       };
7296     } catch (...) {
7297       {
7298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7299       };
7300     }
7301   }
7302
7303   jresult = (void *)result;
7304   return jresult;
7305 }
7306
7307
7308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7309   void * jresult ;
7310   Dali::Vector4 *result = 0 ;
7311
7312   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7313   jresult = (void *)result;
7314   return jresult;
7315 }
7316
7317
7318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7319   void * jresult ;
7320   Dali::Vector4 *result = 0 ;
7321
7322   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7323   jresult = (void *)result;
7324   return jresult;
7325 }
7326
7327
7328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7329   void * jresult ;
7330   Dali::Vector4 *result = 0 ;
7331
7332   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7333   jresult = (void *)result;
7334   return jresult;
7335 }
7336
7337
7338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7339   void * jresult ;
7340   Dali::Vector4 *result = 0 ;
7341
7342   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7343   jresult = (void *)result;
7344   return jresult;
7345 }
7346
7347
7348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7349   void * jresult ;
7350   Dali::Vector4 *result = 0 ;
7351
7352   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7353   jresult = (void *)result;
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7359   void * jresult ;
7360   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7361   float *arg2 = (float *) 0 ;
7362   Dali::Vector4 *result = 0 ;
7363
7364   arg1 = (Dali::Vector4 *)jarg1;
7365   arg2 = jarg2;
7366   {
7367     try {
7368       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7369     } catch (std::out_of_range& e) {
7370       {
7371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7372       };
7373     } catch (std::exception& e) {
7374       {
7375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7376       };
7377     } catch (Dali::DaliException e) {
7378       {
7379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7380       };
7381     } catch (...) {
7382       {
7383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7384       };
7385     }
7386   }
7387
7388   jresult = (void *)result;
7389
7390
7391   return jresult;
7392 }
7393
7394
7395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7396   void * jresult ;
7397   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7398   Dali::Vector2 *arg2 = 0 ;
7399   Dali::Vector4 *result = 0 ;
7400
7401   arg1 = (Dali::Vector4 *)jarg1;
7402   arg2 = (Dali::Vector2 *)jarg2;
7403   if (!arg2) {
7404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7405     return 0;
7406   }
7407   {
7408     try {
7409       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7410     } catch (std::out_of_range& e) {
7411       {
7412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7413       };
7414     } catch (std::exception& e) {
7415       {
7416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (Dali::DaliException e) {
7419       {
7420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428
7429   jresult = (void *)result;
7430   return jresult;
7431 }
7432
7433
7434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7435   void * jresult ;
7436   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7437   Dali::Vector3 *arg2 = 0 ;
7438   Dali::Vector4 *result = 0 ;
7439
7440   arg1 = (Dali::Vector4 *)jarg1;
7441   arg2 = (Dali::Vector3 *)jarg2;
7442   if (!arg2) {
7443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7444     return 0;
7445   }
7446   {
7447     try {
7448       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7449     } catch (std::out_of_range& e) {
7450       {
7451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7452       };
7453     } catch (std::exception& e) {
7454       {
7455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7456       };
7457     } catch (Dali::DaliException e) {
7458       {
7459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7460       };
7461     } catch (...) {
7462       {
7463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7464       };
7465     }
7466   }
7467
7468   jresult = (void *)result;
7469   return jresult;
7470 }
7471
7472
7473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7474   void * jresult ;
7475   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7476   Dali::Vector4 *arg2 = 0 ;
7477   Dali::Vector4 result;
7478
7479   arg1 = (Dali::Vector4 *)jarg1;
7480   arg2 = (Dali::Vector4 *)jarg2;
7481   if (!arg2) {
7482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7483     return 0;
7484   }
7485   {
7486     try {
7487       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7488     } catch (std::out_of_range& e) {
7489       {
7490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7491       };
7492     } catch (std::exception& e) {
7493       {
7494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7495       };
7496     } catch (Dali::DaliException e) {
7497       {
7498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7499       };
7500     } catch (...) {
7501       {
7502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7503       };
7504     }
7505   }
7506
7507   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7508   return jresult;
7509 }
7510
7511
7512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7513   void * jresult ;
7514   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7515   Dali::Vector4 *arg2 = 0 ;
7516   Dali::Vector4 *result = 0 ;
7517
7518   arg1 = (Dali::Vector4 *)jarg1;
7519   arg2 = (Dali::Vector4 *)jarg2;
7520   if (!arg2) {
7521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7522     return 0;
7523   }
7524   {
7525     try {
7526       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7527     } catch (std::out_of_range& e) {
7528       {
7529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7530       };
7531     } catch (std::exception& e) {
7532       {
7533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7534       };
7535     } catch (Dali::DaliException e) {
7536       {
7537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7538       };
7539     } catch (...) {
7540       {
7541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7542       };
7543     }
7544   }
7545
7546   jresult = (void *)result;
7547   return jresult;
7548 }
7549
7550
7551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7552   void * jresult ;
7553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7554   Dali::Vector4 *arg2 = 0 ;
7555   Dali::Vector4 result;
7556
7557   arg1 = (Dali::Vector4 *)jarg1;
7558   arg2 = (Dali::Vector4 *)jarg2;
7559   if (!arg2) {
7560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7561     return 0;
7562   }
7563   {
7564     try {
7565       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7566     } catch (std::out_of_range& e) {
7567       {
7568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7569       };
7570     } catch (std::exception& e) {
7571       {
7572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7573       };
7574     } catch (Dali::DaliException e) {
7575       {
7576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7577       };
7578     } catch (...) {
7579       {
7580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7581       };
7582     }
7583   }
7584
7585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7586   return jresult;
7587 }
7588
7589
7590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7591   void * jresult ;
7592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7593   Dali::Vector4 *arg2 = 0 ;
7594   Dali::Vector4 *result = 0 ;
7595
7596   arg1 = (Dali::Vector4 *)jarg1;
7597   arg2 = (Dali::Vector4 *)jarg2;
7598   if (!arg2) {
7599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7600     return 0;
7601   }
7602   {
7603     try {
7604       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7605     } catch (std::out_of_range& e) {
7606       {
7607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7608       };
7609     } catch (std::exception& e) {
7610       {
7611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7612       };
7613     } catch (Dali::DaliException e) {
7614       {
7615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7616       };
7617     } catch (...) {
7618       {
7619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7620       };
7621     }
7622   }
7623
7624   jresult = (void *)result;
7625   return jresult;
7626 }
7627
7628
7629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7630   void * jresult ;
7631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7632   Dali::Vector4 *arg2 = 0 ;
7633   Dali::Vector4 result;
7634
7635   arg1 = (Dali::Vector4 *)jarg1;
7636   arg2 = (Dali::Vector4 *)jarg2;
7637   if (!arg2) {
7638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7639     return 0;
7640   }
7641   {
7642     try {
7643       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7644     } catch (std::out_of_range& e) {
7645       {
7646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7647       };
7648     } catch (std::exception& e) {
7649       {
7650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7651       };
7652     } catch (Dali::DaliException e) {
7653       {
7654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7655       };
7656     } catch (...) {
7657       {
7658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7659       };
7660     }
7661   }
7662
7663   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7664   return jresult;
7665 }
7666
7667
7668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7669   void * jresult ;
7670   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7671   float arg2 ;
7672   Dali::Vector4 result;
7673
7674   arg1 = (Dali::Vector4 *)jarg1;
7675   arg2 = (float)jarg2;
7676   {
7677     try {
7678       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7679     } catch (std::out_of_range& e) {
7680       {
7681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7682       };
7683     } catch (std::exception& e) {
7684       {
7685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7686       };
7687     } catch (Dali::DaliException e) {
7688       {
7689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7690       };
7691     } catch (...) {
7692       {
7693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7694       };
7695     }
7696   }
7697
7698   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7704   void * jresult ;
7705   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7706   Dali::Vector4 *arg2 = 0 ;
7707   Dali::Vector4 *result = 0 ;
7708
7709   arg1 = (Dali::Vector4 *)jarg1;
7710   arg2 = (Dali::Vector4 *)jarg2;
7711   if (!arg2) {
7712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7713     return 0;
7714   }
7715   {
7716     try {
7717       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7718     } catch (std::out_of_range& e) {
7719       {
7720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7721       };
7722     } catch (std::exception& e) {
7723       {
7724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7725       };
7726     } catch (Dali::DaliException e) {
7727       {
7728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7729       };
7730     } catch (...) {
7731       {
7732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7733       };
7734     }
7735   }
7736
7737   jresult = (void *)result;
7738   return jresult;
7739 }
7740
7741
7742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7743   void * jresult ;
7744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7745   float arg2 ;
7746   Dali::Vector4 *result = 0 ;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   arg2 = (float)jarg2;
7750   {
7751     try {
7752       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7753     } catch (std::out_of_range& e) {
7754       {
7755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7756       };
7757     } catch (std::exception& e) {
7758       {
7759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7760       };
7761     } catch (Dali::DaliException e) {
7762       {
7763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7764       };
7765     } catch (...) {
7766       {
7767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7768       };
7769     }
7770   }
7771
7772   jresult = (void *)result;
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7778   void * jresult ;
7779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7780   Dali::Vector4 *arg2 = 0 ;
7781   Dali::Vector4 result;
7782
7783   arg1 = (Dali::Vector4 *)jarg1;
7784   arg2 = (Dali::Vector4 *)jarg2;
7785   if (!arg2) {
7786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7787     return 0;
7788   }
7789   {
7790     try {
7791       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7792     } catch (std::out_of_range& e) {
7793       {
7794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7795       };
7796     } catch (std::exception& e) {
7797       {
7798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7799       };
7800     } catch (Dali::DaliException e) {
7801       {
7802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7803       };
7804     } catch (...) {
7805       {
7806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7807       };
7808     }
7809   }
7810
7811   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7812   return jresult;
7813 }
7814
7815
7816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7817   void * jresult ;
7818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7819   float arg2 ;
7820   Dali::Vector4 result;
7821
7822   arg1 = (Dali::Vector4 *)jarg1;
7823   arg2 = (float)jarg2;
7824   {
7825     try {
7826       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7827     } catch (std::out_of_range& e) {
7828       {
7829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7830       };
7831     } catch (std::exception& e) {
7832       {
7833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7834       };
7835     } catch (Dali::DaliException e) {
7836       {
7837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7838       };
7839     } catch (...) {
7840       {
7841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7842       };
7843     }
7844   }
7845
7846   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7847   return jresult;
7848 }
7849
7850
7851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7852   void * jresult ;
7853   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7854   Dali::Vector4 *arg2 = 0 ;
7855   Dali::Vector4 *result = 0 ;
7856
7857   arg1 = (Dali::Vector4 *)jarg1;
7858   arg2 = (Dali::Vector4 *)jarg2;
7859   if (!arg2) {
7860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7861     return 0;
7862   }
7863   {
7864     try {
7865       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7866     } catch (std::out_of_range& e) {
7867       {
7868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7869       };
7870     } catch (std::exception& e) {
7871       {
7872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7873       };
7874     } catch (Dali::DaliException e) {
7875       {
7876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7877       };
7878     } catch (...) {
7879       {
7880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7881       };
7882     }
7883   }
7884
7885   jresult = (void *)result;
7886   return jresult;
7887 }
7888
7889
7890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7891   void * jresult ;
7892   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7893   float arg2 ;
7894   Dali::Vector4 *result = 0 ;
7895
7896   arg1 = (Dali::Vector4 *)jarg1;
7897   arg2 = (float)jarg2;
7898   {
7899     try {
7900       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7901     } catch (std::out_of_range& e) {
7902       {
7903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7904       };
7905     } catch (std::exception& e) {
7906       {
7907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7908       };
7909     } catch (Dali::DaliException e) {
7910       {
7911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7912       };
7913     } catch (...) {
7914       {
7915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7916       };
7917     }
7918   }
7919
7920   jresult = (void *)result;
7921   return jresult;
7922 }
7923
7924
7925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7926   void * jresult ;
7927   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7928   Dali::Vector4 result;
7929
7930   arg1 = (Dali::Vector4 *)jarg1;
7931   {
7932     try {
7933       result = ((Dali::Vector4 const *)arg1)->operator -();
7934     } catch (std::out_of_range& e) {
7935       {
7936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (std::exception& e) {
7939       {
7940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7941       };
7942     } catch (Dali::DaliException e) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7945       };
7946     } catch (...) {
7947       {
7948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7949       };
7950     }
7951   }
7952
7953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7954   return jresult;
7955 }
7956
7957
7958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7959   unsigned int jresult ;
7960   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7961   Dali::Vector4 *arg2 = 0 ;
7962   bool result;
7963
7964   arg1 = (Dali::Vector4 *)jarg1;
7965   arg2 = (Dali::Vector4 *)jarg2;
7966   if (!arg2) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7968     return 0;
7969   }
7970   {
7971     try {
7972       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7973     } catch (std::out_of_range& e) {
7974       {
7975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7976       };
7977     } catch (std::exception& e) {
7978       {
7979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7980       };
7981     } catch (Dali::DaliException e) {
7982       {
7983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7984       };
7985     } catch (...) {
7986       {
7987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7988       };
7989     }
7990   }
7991
7992   jresult = result;
7993   return jresult;
7994 }
7995
7996
7997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7998   unsigned int jresult ;
7999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8000   Dali::Vector4 *arg2 = 0 ;
8001   bool result;
8002
8003   arg1 = (Dali::Vector4 *)jarg1;
8004   arg2 = (Dali::Vector4 *)jarg2;
8005   if (!arg2) {
8006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8007     return 0;
8008   }
8009   {
8010     try {
8011       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8012     } catch (std::out_of_range& e) {
8013       {
8014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8015       };
8016     } catch (std::exception& e) {
8017       {
8018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8019       };
8020     } catch (Dali::DaliException e) {
8021       {
8022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8023       };
8024     } catch (...) {
8025       {
8026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8027       };
8028     }
8029   }
8030
8031   jresult = result;
8032   return jresult;
8033 }
8034
8035
8036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8037   float jresult ;
8038   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8039   unsigned int arg2 ;
8040   float *result = 0 ;
8041
8042   arg1 = (Dali::Vector4 *)jarg1;
8043   arg2 = (unsigned int)jarg2;
8044   {
8045     try {
8046       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8047     } catch (std::out_of_range& e) {
8048       {
8049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8050       };
8051     } catch (std::exception& e) {
8052       {
8053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8054       };
8055     } catch (Dali::DaliException e) {
8056       {
8057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8058       };
8059     } catch (...) {
8060       {
8061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8062       };
8063     }
8064   }
8065
8066   jresult = *result;
8067   return jresult;
8068 }
8069
8070
8071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8072   float jresult ;
8073   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8074   Dali::Vector3 *arg2 = 0 ;
8075   float result;
8076
8077   arg1 = (Dali::Vector4 *)jarg1;
8078   arg2 = (Dali::Vector3 *)jarg2;
8079   if (!arg2) {
8080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8081     return 0;
8082   }
8083   {
8084     try {
8085       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8086     } catch (std::out_of_range& e) {
8087       {
8088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8089       };
8090     } catch (std::exception& e) {
8091       {
8092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8093       };
8094     } catch (Dali::DaliException e) {
8095       {
8096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8097       };
8098     } catch (...) {
8099       {
8100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8101       };
8102     }
8103   }
8104
8105   jresult = result;
8106   return jresult;
8107 }
8108
8109
8110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8111   float jresult ;
8112   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8113   Dali::Vector4 *arg2 = 0 ;
8114   float result;
8115
8116   arg1 = (Dali::Vector4 *)jarg1;
8117   arg2 = (Dali::Vector4 *)jarg2;
8118   if (!arg2) {
8119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8120     return 0;
8121   }
8122   {
8123     try {
8124       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8125     } catch (std::out_of_range& e) {
8126       {
8127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8128       };
8129     } catch (std::exception& e) {
8130       {
8131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8132       };
8133     } catch (Dali::DaliException e) {
8134       {
8135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8136       };
8137     } catch (...) {
8138       {
8139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8140       };
8141     }
8142   }
8143
8144   jresult = result;
8145   return jresult;
8146 }
8147
8148
8149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8150   float jresult ;
8151   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8152   Dali::Vector4 *arg2 = 0 ;
8153   float result;
8154
8155   arg1 = (Dali::Vector4 *)jarg1;
8156   arg2 = (Dali::Vector4 *)jarg2;
8157   if (!arg2) {
8158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8159     return 0;
8160   }
8161   {
8162     try {
8163       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8164     } catch (std::out_of_range& e) {
8165       {
8166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8167       };
8168     } catch (std::exception& e) {
8169       {
8170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8171       };
8172     } catch (Dali::DaliException e) {
8173       {
8174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8175       };
8176     } catch (...) {
8177       {
8178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8179       };
8180     }
8181   }
8182
8183   jresult = result;
8184   return jresult;
8185 }
8186
8187
8188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8189   void * jresult ;
8190   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8191   Dali::Vector4 *arg2 = 0 ;
8192   Dali::Vector4 result;
8193
8194   arg1 = (Dali::Vector4 *)jarg1;
8195   arg2 = (Dali::Vector4 *)jarg2;
8196   if (!arg2) {
8197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8198     return 0;
8199   }
8200   {
8201     try {
8202       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8203     } catch (std::out_of_range& e) {
8204       {
8205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8206       };
8207     } catch (std::exception& e) {
8208       {
8209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8210       };
8211     } catch (Dali::DaliException e) {
8212       {
8213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8214       };
8215     } catch (...) {
8216       {
8217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8218       };
8219     }
8220   }
8221
8222   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8223   return jresult;
8224 }
8225
8226
8227 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8228   float jresult ;
8229   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8230   float result;
8231
8232   arg1 = (Dali::Vector4 *)jarg1;
8233   {
8234     try {
8235       result = (float)((Dali::Vector4 const *)arg1)->Length();
8236     } catch (std::out_of_range& e) {
8237       {
8238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8239       };
8240     } catch (std::exception& e) {
8241       {
8242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8243       };
8244     } catch (Dali::DaliException e) {
8245       {
8246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8247       };
8248     } catch (...) {
8249       {
8250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8251       };
8252     }
8253   }
8254
8255   jresult = result;
8256   return jresult;
8257 }
8258
8259
8260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8261   float jresult ;
8262   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8263   float result;
8264
8265   arg1 = (Dali::Vector4 *)jarg1;
8266   {
8267     try {
8268       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8269     } catch (std::out_of_range& e) {
8270       {
8271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (std::exception& e) {
8274       {
8275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8276       };
8277     } catch (Dali::DaliException e) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8280       };
8281     } catch (...) {
8282       {
8283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8284       };
8285     }
8286   }
8287
8288   jresult = result;
8289   return jresult;
8290 }
8291
8292
8293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8294   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8295
8296   arg1 = (Dali::Vector4 *)jarg1;
8297   {
8298     try {
8299       (arg1)->Normalize();
8300     } catch (std::out_of_range& e) {
8301       {
8302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8303       };
8304     } catch (std::exception& e) {
8305       {
8306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8307       };
8308     } catch (Dali::DaliException e) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8311       };
8312     } catch (...) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8315       };
8316     }
8317   }
8318
8319 }
8320
8321
8322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8323   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8324   Dali::Vector4 *arg2 = 0 ;
8325   Dali::Vector4 *arg3 = 0 ;
8326
8327   arg1 = (Dali::Vector4 *)jarg1;
8328   arg2 = (Dali::Vector4 *)jarg2;
8329   if (!arg2) {
8330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8331     return ;
8332   }
8333   arg3 = (Dali::Vector4 *)jarg3;
8334   if (!arg3) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8336     return ;
8337   }
8338   {
8339     try {
8340       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8348       };
8349     } catch (Dali::DaliException e) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8356       };
8357     }
8358   }
8359
8360 }
8361
8362
8363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8364   void * jresult ;
8365   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8366   float *result = 0 ;
8367
8368   arg1 = (Dali::Vector4 *)jarg1;
8369   {
8370     try {
8371       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8372     } catch (std::out_of_range& e) {
8373       {
8374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (std::exception& e) {
8377       {
8378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (Dali::DaliException e) {
8381       {
8382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8383       };
8384     } catch (...) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8387       };
8388     }
8389   }
8390
8391   jresult = (void *)result;
8392   return jresult;
8393 }
8394
8395
8396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8397   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8398   float arg2 ;
8399
8400   arg1 = (Dali::Vector4 *)jarg1;
8401   arg2 = (float)jarg2;
8402   if (arg1) (arg1)->x = arg2;
8403 }
8404
8405
8406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8407   float jresult ;
8408   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8409   float result;
8410
8411   arg1 = (Dali::Vector4 *)jarg1;
8412   result = (float) ((arg1)->x);
8413   jresult = result;
8414   return jresult;
8415 }
8416
8417
8418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8419   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8420   float arg2 ;
8421
8422   arg1 = (Dali::Vector4 *)jarg1;
8423   arg2 = (float)jarg2;
8424   if (arg1) (arg1)->r = arg2;
8425 }
8426
8427
8428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8429   float jresult ;
8430   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8431   float result;
8432
8433   arg1 = (Dali::Vector4 *)jarg1;
8434   result = (float) ((arg1)->r);
8435   jresult = result;
8436   return jresult;
8437 }
8438
8439
8440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8441   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8442   float arg2 ;
8443
8444   arg1 = (Dali::Vector4 *)jarg1;
8445   arg2 = (float)jarg2;
8446   if (arg1) (arg1)->s = arg2;
8447 }
8448
8449
8450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8451   float jresult ;
8452   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8453   float result;
8454
8455   arg1 = (Dali::Vector4 *)jarg1;
8456   result = (float) ((arg1)->s);
8457   jresult = result;
8458   return jresult;
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   float arg2 ;
8465
8466   arg1 = (Dali::Vector4 *)jarg1;
8467   arg2 = (float)jarg2;
8468   if (arg1) (arg1)->y = arg2;
8469 }
8470
8471
8472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8473   float jresult ;
8474   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8475   float result;
8476
8477   arg1 = (Dali::Vector4 *)jarg1;
8478   result = (float) ((arg1)->y);
8479   jresult = result;
8480   return jresult;
8481 }
8482
8483
8484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8485   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8486   float arg2 ;
8487
8488   arg1 = (Dali::Vector4 *)jarg1;
8489   arg2 = (float)jarg2;
8490   if (arg1) (arg1)->g = arg2;
8491 }
8492
8493
8494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8495   float jresult ;
8496   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8497   float result;
8498
8499   arg1 = (Dali::Vector4 *)jarg1;
8500   result = (float) ((arg1)->g);
8501   jresult = result;
8502   return jresult;
8503 }
8504
8505
8506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8507   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8508   float arg2 ;
8509
8510   arg1 = (Dali::Vector4 *)jarg1;
8511   arg2 = (float)jarg2;
8512   if (arg1) (arg1)->t = arg2;
8513 }
8514
8515
8516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8517   float jresult ;
8518   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8519   float result;
8520
8521   arg1 = (Dali::Vector4 *)jarg1;
8522   result = (float) ((arg1)->t);
8523   jresult = result;
8524   return jresult;
8525 }
8526
8527
8528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8530   float arg2 ;
8531
8532   arg1 = (Dali::Vector4 *)jarg1;
8533   arg2 = (float)jarg2;
8534   if (arg1) (arg1)->z = arg2;
8535 }
8536
8537
8538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8539   float jresult ;
8540   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8541   float result;
8542
8543   arg1 = (Dali::Vector4 *)jarg1;
8544   result = (float) ((arg1)->z);
8545   jresult = result;
8546   return jresult;
8547 }
8548
8549
8550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8552   float arg2 ;
8553
8554   arg1 = (Dali::Vector4 *)jarg1;
8555   arg2 = (float)jarg2;
8556   if (arg1) (arg1)->b = arg2;
8557 }
8558
8559
8560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8561   float jresult ;
8562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8563   float result;
8564
8565   arg1 = (Dali::Vector4 *)jarg1;
8566   result = (float) ((arg1)->b);
8567   jresult = result;
8568   return jresult;
8569 }
8570
8571
8572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8574   float arg2 ;
8575
8576   arg1 = (Dali::Vector4 *)jarg1;
8577   arg2 = (float)jarg2;
8578   if (arg1) (arg1)->p = arg2;
8579 }
8580
8581
8582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8583   float jresult ;
8584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8585   float result;
8586
8587   arg1 = (Dali::Vector4 *)jarg1;
8588   result = (float) ((arg1)->p);
8589   jresult = result;
8590   return jresult;
8591 }
8592
8593
8594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8595   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8596   float arg2 ;
8597
8598   arg1 = (Dali::Vector4 *)jarg1;
8599   arg2 = (float)jarg2;
8600   if (arg1) (arg1)->w = arg2;
8601 }
8602
8603
8604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8605   float jresult ;
8606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8607   float result;
8608
8609   arg1 = (Dali::Vector4 *)jarg1;
8610   result = (float) ((arg1)->w);
8611   jresult = result;
8612   return jresult;
8613 }
8614
8615
8616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8617   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8618   float arg2 ;
8619
8620   arg1 = (Dali::Vector4 *)jarg1;
8621   arg2 = (float)jarg2;
8622   if (arg1) (arg1)->a = arg2;
8623 }
8624
8625
8626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8627   float jresult ;
8628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8629   float result;
8630
8631   arg1 = (Dali::Vector4 *)jarg1;
8632   result = (float) ((arg1)->a);
8633   jresult = result;
8634   return jresult;
8635 }
8636
8637
8638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8639   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8640   float arg2 ;
8641
8642   arg1 = (Dali::Vector4 *)jarg1;
8643   arg2 = (float)jarg2;
8644   if (arg1) (arg1)->q = arg2;
8645 }
8646
8647
8648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8649   float jresult ;
8650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8651   float result;
8652
8653   arg1 = (Dali::Vector4 *)jarg1;
8654   result = (float) ((arg1)->q);
8655   jresult = result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8661   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8662
8663   arg1 = (Dali::Vector4 *)jarg1;
8664   {
8665     try {
8666       delete arg1;
8667     } catch (std::out_of_range& e) {
8668       {
8669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8670       };
8671     } catch (std::exception& e) {
8672       {
8673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8674       };
8675     } catch (Dali::DaliException e) {
8676       {
8677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8678       };
8679     } catch (...) {
8680       {
8681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8682       };
8683     }
8684   }
8685
8686 }
8687
8688
8689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8690   void * jresult ;
8691   Dali::Vector4 *arg1 = 0 ;
8692   Dali::Vector4 *arg2 = 0 ;
8693   Dali::Vector4 result;
8694
8695   arg1 = (Dali::Vector4 *)jarg1;
8696   if (!arg1) {
8697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8698     return 0;
8699   }
8700   arg2 = (Dali::Vector4 *)jarg2;
8701   if (!arg2) {
8702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8703     return 0;
8704   }
8705   {
8706     try {
8707       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8708     } catch (std::out_of_range& e) {
8709       {
8710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8711       };
8712     } catch (std::exception& e) {
8713       {
8714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8715       };
8716     } catch (Dali::DaliException e) {
8717       {
8718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8719       };
8720     } catch (...) {
8721       {
8722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8723       };
8724     }
8725   }
8726
8727   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8733   void * jresult ;
8734   Dali::Vector4 *arg1 = 0 ;
8735   Dali::Vector4 *arg2 = 0 ;
8736   Dali::Vector4 result;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   if (!arg1) {
8740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8741     return 0;
8742   }
8743   arg2 = (Dali::Vector4 *)jarg2;
8744   if (!arg2) {
8745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8746     return 0;
8747   }
8748   {
8749     try {
8750       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8751     } catch (std::out_of_range& e) {
8752       {
8753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8754       };
8755     } catch (std::exception& e) {
8756       {
8757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8758       };
8759     } catch (Dali::DaliException e) {
8760       {
8761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8762       };
8763     } catch (...) {
8764       {
8765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8766       };
8767     }
8768   }
8769
8770   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8776   void * jresult ;
8777   Dali::Vector4 *arg1 = 0 ;
8778   float *arg2 = 0 ;
8779   float *arg3 = 0 ;
8780   float temp2 ;
8781   float temp3 ;
8782   Dali::Vector4 result;
8783
8784   arg1 = (Dali::Vector4 *)jarg1;
8785   if (!arg1) {
8786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8787     return 0;
8788   }
8789   temp2 = (float)jarg2;
8790   arg2 = &temp2;
8791   temp3 = (float)jarg3;
8792   arg3 = &temp3;
8793   {
8794     try {
8795       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8796     } catch (std::out_of_range& e) {
8797       {
8798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8799       };
8800     } catch (std::exception& e) {
8801       {
8802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8803       };
8804     } catch (Dali::DaliException e) {
8805       {
8806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8807       };
8808     } catch (...) {
8809       {
8810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8811       };
8812     }
8813   }
8814
8815   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8816   return jresult;
8817 }
8818
8819
8820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8821   void * jresult ;
8822   Dali::Uint16Pair *result = 0 ;
8823
8824   {
8825     try {
8826       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8827     } catch (std::out_of_range& e) {
8828       {
8829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8830       };
8831     } catch (std::exception& e) {
8832       {
8833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8834       };
8835     } catch (Dali::DaliException e) {
8836       {
8837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8838       };
8839     } catch (...) {
8840       {
8841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8842       };
8843     }
8844   }
8845
8846   jresult = (void *)result;
8847   return jresult;
8848 }
8849
8850
8851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8852   void * jresult ;
8853   uint32_t arg1 ;
8854   uint32_t arg2 ;
8855   Dali::Uint16Pair *result = 0 ;
8856
8857   arg1 = (uint32_t)jarg1;
8858   arg2 = (uint32_t)jarg2;
8859   {
8860     try {
8861       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8862     } catch (std::out_of_range& e) {
8863       {
8864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8865       };
8866     } catch (std::exception& e) {
8867       {
8868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8869       };
8870     } catch (Dali::DaliException e) {
8871       {
8872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8873       };
8874     } catch (...) {
8875       {
8876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8877       };
8878     }
8879   }
8880
8881   jresult = (void *)result;
8882   return jresult;
8883 }
8884
8885
8886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8887   void * jresult ;
8888   Dali::Uint16Pair *arg1 = 0 ;
8889   Dali::Uint16Pair *result = 0 ;
8890
8891   arg1 = (Dali::Uint16Pair *)jarg1;
8892   if (!arg1) {
8893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8894     return 0;
8895   }
8896   {
8897     try {
8898       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8899     } catch (std::out_of_range& e) {
8900       {
8901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8902       };
8903     } catch (std::exception& e) {
8904       {
8905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (Dali::DaliException e) {
8908       {
8909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8910       };
8911     } catch (...) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8914       };
8915     }
8916   }
8917
8918   jresult = (void *)result;
8919   return jresult;
8920 }
8921
8922
8923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8924   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8925   uint16_t arg2 ;
8926
8927   arg1 = (Dali::Uint16Pair *)jarg1;
8928   arg2 = (uint16_t)jarg2;
8929   {
8930     try {
8931       (arg1)->SetWidth(arg2);
8932     } catch (std::out_of_range& e) {
8933       {
8934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8935       };
8936     } catch (std::exception& e) {
8937       {
8938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8939       };
8940     } catch (Dali::DaliException e) {
8941       {
8942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8943       };
8944     } catch (...) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8947       };
8948     }
8949   }
8950
8951 }
8952
8953
8954 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8955   unsigned short jresult ;
8956   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8957   uint16_t result;
8958
8959   arg1 = (Dali::Uint16Pair *)jarg1;
8960   {
8961     try {
8962       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8963     } catch (std::out_of_range& e) {
8964       {
8965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8966       };
8967     } catch (std::exception& e) {
8968       {
8969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (Dali::DaliException e) {
8972       {
8973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8974       };
8975     } catch (...) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8978       };
8979     }
8980   }
8981
8982   jresult = result;
8983   return jresult;
8984 }
8985
8986
8987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8988   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8989   uint16_t arg2 ;
8990
8991   arg1 = (Dali::Uint16Pair *)jarg1;
8992   arg2 = (uint16_t)jarg2;
8993   {
8994     try {
8995       (arg1)->SetHeight(arg2);
8996     } catch (std::out_of_range& e) {
8997       {
8998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8999       };
9000     } catch (std::exception& e) {
9001       {
9002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9003       };
9004     } catch (Dali::DaliException e) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9007       };
9008     } catch (...) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9011       };
9012     }
9013   }
9014
9015 }
9016
9017
9018 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9019   unsigned short jresult ;
9020   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9021   uint16_t result;
9022
9023   arg1 = (Dali::Uint16Pair *)jarg1;
9024   {
9025     try {
9026       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9027     } catch (std::out_of_range& e) {
9028       {
9029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9030       };
9031     } catch (std::exception& e) {
9032       {
9033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9034       };
9035     } catch (Dali::DaliException e) {
9036       {
9037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9038       };
9039     } catch (...) {
9040       {
9041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9042       };
9043     }
9044   }
9045
9046   jresult = result;
9047   return jresult;
9048 }
9049
9050
9051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9052   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9053   uint16_t arg2 ;
9054
9055   arg1 = (Dali::Uint16Pair *)jarg1;
9056   arg2 = (uint16_t)jarg2;
9057   {
9058     try {
9059       (arg1)->SetX(arg2);
9060     } catch (std::out_of_range& e) {
9061       {
9062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9063       };
9064     } catch (std::exception& e) {
9065       {
9066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9067       };
9068     } catch (Dali::DaliException e) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9071       };
9072     } catch (...) {
9073       {
9074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9075       };
9076     }
9077   }
9078
9079 }
9080
9081
9082 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9083   unsigned short jresult ;
9084   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9085   uint16_t result;
9086
9087   arg1 = (Dali::Uint16Pair *)jarg1;
9088   {
9089     try {
9090       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9091     } catch (std::out_of_range& e) {
9092       {
9093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9094       };
9095     } catch (std::exception& e) {
9096       {
9097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9098       };
9099     } catch (Dali::DaliException e) {
9100       {
9101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9102       };
9103     } catch (...) {
9104       {
9105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9106       };
9107     }
9108   }
9109
9110   jresult = result;
9111   return jresult;
9112 }
9113
9114
9115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9116   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9117   uint16_t arg2 ;
9118
9119   arg1 = (Dali::Uint16Pair *)jarg1;
9120   arg2 = (uint16_t)jarg2;
9121   {
9122     try {
9123       (arg1)->SetY(arg2);
9124     } catch (std::out_of_range& e) {
9125       {
9126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9127       };
9128     } catch (std::exception& e) {
9129       {
9130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9131       };
9132     } catch (Dali::DaliException e) {
9133       {
9134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9135       };
9136     } catch (...) {
9137       {
9138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9139       };
9140     }
9141   }
9142
9143 }
9144
9145
9146 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9147   unsigned short jresult ;
9148   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9149   uint16_t result;
9150
9151   arg1 = (Dali::Uint16Pair *)jarg1;
9152   {
9153     try {
9154       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9155     } catch (std::out_of_range& e) {
9156       {
9157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9158       };
9159     } catch (std::exception& e) {
9160       {
9161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9162       };
9163     } catch (Dali::DaliException e) {
9164       {
9165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9166       };
9167     } catch (...) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9170       };
9171     }
9172   }
9173
9174   jresult = result;
9175   return jresult;
9176 }
9177
9178
9179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9180   void * jresult ;
9181   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9182   Dali::Uint16Pair *arg2 = 0 ;
9183   Dali::Uint16Pair *result = 0 ;
9184
9185   arg1 = (Dali::Uint16Pair *)jarg1;
9186   arg2 = (Dali::Uint16Pair *)jarg2;
9187   if (!arg2) {
9188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9189     return 0;
9190   }
9191   {
9192     try {
9193       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9194     } catch (std::out_of_range& e) {
9195       {
9196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9197       };
9198     } catch (std::exception& e) {
9199       {
9200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9201       };
9202     } catch (Dali::DaliException e) {
9203       {
9204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9205       };
9206     } catch (...) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9209       };
9210     }
9211   }
9212
9213   jresult = (void *)result;
9214   return jresult;
9215 }
9216
9217
9218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9219   unsigned int jresult ;
9220   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9221   Dali::Uint16Pair *arg2 = 0 ;
9222   bool result;
9223
9224   arg1 = (Dali::Uint16Pair *)jarg1;
9225   arg2 = (Dali::Uint16Pair *)jarg2;
9226   if (!arg2) {
9227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9228     return 0;
9229   }
9230   {
9231     try {
9232       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9233     } catch (std::out_of_range& e) {
9234       {
9235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (std::exception& e) {
9238       {
9239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9240       };
9241     } catch (Dali::DaliException e) {
9242       {
9243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9244       };
9245     } catch (...) {
9246       {
9247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9248       };
9249     }
9250   }
9251
9252   jresult = result;
9253   return jresult;
9254 }
9255
9256
9257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9258   unsigned int jresult ;
9259   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9260   Dali::Uint16Pair *arg2 = 0 ;
9261   bool result;
9262
9263   arg1 = (Dali::Uint16Pair *)jarg1;
9264   arg2 = (Dali::Uint16Pair *)jarg2;
9265   if (!arg2) {
9266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9267     return 0;
9268   }
9269   {
9270     try {
9271       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9272     } catch (std::out_of_range& e) {
9273       {
9274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9275       };
9276     } catch (std::exception& e) {
9277       {
9278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9279       };
9280     } catch (Dali::DaliException e) {
9281       {
9282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9283       };
9284     } catch (...) {
9285       {
9286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9287       };
9288     }
9289   }
9290
9291   jresult = result;
9292   return jresult;
9293 }
9294
9295
9296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9297   unsigned int jresult ;
9298   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9299   Dali::Uint16Pair *arg2 = 0 ;
9300   bool result;
9301
9302   arg1 = (Dali::Uint16Pair *)jarg1;
9303   arg2 = (Dali::Uint16Pair *)jarg2;
9304   if (!arg2) {
9305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9306     return 0;
9307   }
9308   {
9309     try {
9310       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9311     } catch (std::out_of_range& e) {
9312       {
9313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9314       };
9315     } catch (std::exception& e) {
9316       {
9317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9318       };
9319     } catch (Dali::DaliException e) {
9320       {
9321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9322       };
9323     } catch (...) {
9324       {
9325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9326       };
9327     }
9328   }
9329
9330   jresult = result;
9331   return jresult;
9332 }
9333
9334
9335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9336   unsigned int jresult ;
9337   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9338   Dali::Uint16Pair *arg2 = 0 ;
9339   bool result;
9340
9341   arg1 = (Dali::Uint16Pair *)jarg1;
9342   arg2 = (Dali::Uint16Pair *)jarg2;
9343   if (!arg2) {
9344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9345     return 0;
9346   }
9347   {
9348     try {
9349       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9350     } catch (std::out_of_range& e) {
9351       {
9352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9353       };
9354     } catch (std::exception& e) {
9355       {
9356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9357       };
9358     } catch (Dali::DaliException e) {
9359       {
9360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9361       };
9362     } catch (...) {
9363       {
9364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9365       };
9366     }
9367   }
9368
9369   jresult = result;
9370   return jresult;
9371 }
9372
9373
9374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9375   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9376
9377   arg1 = (Dali::Uint16Pair *)jarg1;
9378   {
9379     try {
9380       delete arg1;
9381     } catch (std::out_of_range& e) {
9382       {
9383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9384       };
9385     } catch (std::exception& e) {
9386       {
9387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9388       };
9389     } catch (Dali::DaliException e) {
9390       {
9391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9392       };
9393     } catch (...) {
9394       {
9395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9396       };
9397     }
9398   }
9399
9400 }
9401
9402
9403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9404   void * jresult ;
9405   Dali::Degree *result = 0 ;
9406
9407   {
9408     try {
9409       result = (Dali::Degree *)new Dali::Degree();
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (Dali::DaliException e) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428
9429   jresult = (void *)result;
9430   return jresult;
9431 }
9432
9433
9434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9435   void * jresult ;
9436   float arg1 ;
9437   Dali::Degree *result = 0 ;
9438
9439   arg1 = (float)jarg1;
9440   {
9441     try {
9442       result = (Dali::Degree *)new Dali::Degree(arg1);
9443     } catch (std::out_of_range& e) {
9444       {
9445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (std::exception& e) {
9448       {
9449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (Dali::DaliException e) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9454       };
9455     } catch (...) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9458       };
9459     }
9460   }
9461
9462   jresult = (void *)result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9468   void * jresult ;
9469   Dali::Radian arg1 ;
9470   Dali::Radian *argp1 ;
9471   Dali::Degree *result = 0 ;
9472
9473   argp1 = (Dali::Radian *)jarg1;
9474   if (!argp1) {
9475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9476     return 0;
9477   }
9478   arg1 = *argp1;
9479   {
9480     try {
9481       result = (Dali::Degree *)new Dali::Degree(arg1);
9482     } catch (std::out_of_range& e) {
9483       {
9484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9485       };
9486     } catch (std::exception& e) {
9487       {
9488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9489       };
9490     } catch (Dali::DaliException e) {
9491       {
9492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9493       };
9494     } catch (...) {
9495       {
9496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9497       };
9498     }
9499   }
9500
9501   jresult = (void *)result;
9502   return jresult;
9503 }
9504
9505
9506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9507   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9508   float arg2 ;
9509
9510   arg1 = (Dali::Degree *)jarg1;
9511   arg2 = (float)jarg2;
9512   if (arg1) (arg1)->degree = arg2;
9513 }
9514
9515
9516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9517   float jresult ;
9518   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9519   float result;
9520
9521   arg1 = (Dali::Degree *)jarg1;
9522   result = (float) ((arg1)->degree);
9523   jresult = result;
9524   return jresult;
9525 }
9526
9527
9528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9529   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9530
9531   arg1 = (Dali::Degree *)jarg1;
9532   {
9533     try {
9534       delete arg1;
9535     } catch (std::out_of_range& e) {
9536       {
9537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9538       };
9539     } catch (std::exception& e) {
9540       {
9541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9542       };
9543     } catch (Dali::DaliException e) {
9544       {
9545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9546       };
9547     } catch (...) {
9548       {
9549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9550       };
9551     }
9552   }
9553
9554 }
9555
9556
9557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9558   void * jresult ;
9559   Dali::Radian *result = 0 ;
9560
9561   result = (Dali::Radian *)&Dali::ANGLE_360;
9562   jresult = (void *)result;
9563   return jresult;
9564 }
9565
9566
9567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9568   void * jresult ;
9569   Dali::Radian *result = 0 ;
9570
9571   result = (Dali::Radian *)&Dali::ANGLE_315;
9572   jresult = (void *)result;
9573   return jresult;
9574 }
9575
9576
9577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9578   void * jresult ;
9579   Dali::Radian *result = 0 ;
9580
9581   result = (Dali::Radian *)&Dali::ANGLE_270;
9582   jresult = (void *)result;
9583   return jresult;
9584 }
9585
9586
9587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9588   void * jresult ;
9589   Dali::Radian *result = 0 ;
9590
9591   result = (Dali::Radian *)&Dali::ANGLE_225;
9592   jresult = (void *)result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9598   void * jresult ;
9599   Dali::Radian *result = 0 ;
9600
9601   result = (Dali::Radian *)&Dali::ANGLE_180;
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9608   void * jresult ;
9609   Dali::Radian *result = 0 ;
9610
9611   result = (Dali::Radian *)&Dali::ANGLE_135;
9612   jresult = (void *)result;
9613   return jresult;
9614 }
9615
9616
9617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9618   void * jresult ;
9619   Dali::Radian *result = 0 ;
9620
9621   result = (Dali::Radian *)&Dali::ANGLE_120;
9622   jresult = (void *)result;
9623   return jresult;
9624 }
9625
9626
9627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9628   void * jresult ;
9629   Dali::Radian *result = 0 ;
9630
9631   result = (Dali::Radian *)&Dali::ANGLE_90;
9632   jresult = (void *)result;
9633   return jresult;
9634 }
9635
9636
9637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9638   void * jresult ;
9639   Dali::Radian *result = 0 ;
9640
9641   result = (Dali::Radian *)&Dali::ANGLE_60;
9642   jresult = (void *)result;
9643   return jresult;
9644 }
9645
9646
9647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9648   void * jresult ;
9649   Dali::Radian *result = 0 ;
9650
9651   result = (Dali::Radian *)&Dali::ANGLE_45;
9652   jresult = (void *)result;
9653   return jresult;
9654 }
9655
9656
9657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9658   void * jresult ;
9659   Dali::Radian *result = 0 ;
9660
9661   result = (Dali::Radian *)&Dali::ANGLE_30;
9662   jresult = (void *)result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9668   void * jresult ;
9669   Dali::Radian *result = 0 ;
9670
9671   result = (Dali::Radian *)&Dali::ANGLE_0;
9672   jresult = (void *)result;
9673   return jresult;
9674 }
9675
9676
9677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9678   unsigned int jresult ;
9679   Dali::Degree *arg1 = 0 ;
9680   Dali::Degree *arg2 = 0 ;
9681   bool result;
9682
9683   arg1 = (Dali::Degree *)jarg1;
9684   if (!arg1) {
9685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9686     return 0;
9687   }
9688   arg2 = (Dali::Degree *)jarg2;
9689   if (!arg2) {
9690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9691     return 0;
9692   }
9693   {
9694     try {
9695       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9696     } catch (std::out_of_range& e) {
9697       {
9698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9699       };
9700     } catch (std::exception& e) {
9701       {
9702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9703       };
9704     } catch (Dali::DaliException e) {
9705       {
9706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9707       };
9708     } catch (...) {
9709       {
9710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9711       };
9712     }
9713   }
9714
9715   jresult = result;
9716   return jresult;
9717 }
9718
9719
9720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9721   unsigned int jresult ;
9722   Dali::Degree *arg1 = 0 ;
9723   Dali::Degree *arg2 = 0 ;
9724   bool result;
9725
9726   arg1 = (Dali::Degree *)jarg1;
9727   if (!arg1) {
9728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9729     return 0;
9730   }
9731   arg2 = (Dali::Degree *)jarg2;
9732   if (!arg2) {
9733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9734     return 0;
9735   }
9736   {
9737     try {
9738       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9739     } catch (std::out_of_range& e) {
9740       {
9741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9742       };
9743     } catch (std::exception& e) {
9744       {
9745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9746       };
9747     } catch (Dali::DaliException e) {
9748       {
9749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9750       };
9751     } catch (...) {
9752       {
9753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9754       };
9755     }
9756   }
9757
9758   jresult = result;
9759   return jresult;
9760 }
9761
9762
9763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9764   void * jresult ;
9765   Dali::Degree arg1 ;
9766   float arg2 ;
9767   float arg3 ;
9768   Dali::Degree *argp1 ;
9769   Dali::Degree result;
9770
9771   argp1 = (Dali::Degree *)jarg1;
9772   if (!argp1) {
9773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9774     return 0;
9775   }
9776   arg1 = *argp1;
9777   arg2 = (float)jarg2;
9778   arg3 = (float)jarg3;
9779   {
9780     try {
9781       result = Dali::Clamp(arg1,arg2,arg3);
9782     } catch (std::out_of_range& e) {
9783       {
9784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9785       };
9786     } catch (std::exception& e) {
9787       {
9788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9789       };
9790     } catch (Dali::DaliException e) {
9791       {
9792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9793       };
9794     } catch (...) {
9795       {
9796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9797       };
9798     }
9799   }
9800
9801   jresult = new Dali::Degree((const Dali::Degree &)result);
9802   return jresult;
9803 }
9804
9805
9806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9807   void * jresult ;
9808   Dali::Radian *result = 0 ;
9809
9810   {
9811     try {
9812       result = (Dali::Radian *)new Dali::Radian();
9813     } catch (std::out_of_range& e) {
9814       {
9815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9816       };
9817     } catch (std::exception& e) {
9818       {
9819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9820       };
9821     } catch (Dali::DaliException e) {
9822       {
9823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9824       };
9825     } catch (...) {
9826       {
9827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9828       };
9829     }
9830   }
9831
9832   jresult = (void *)result;
9833   return jresult;
9834 }
9835
9836
9837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9838   void * jresult ;
9839   float arg1 ;
9840   Dali::Radian *result = 0 ;
9841
9842   arg1 = (float)jarg1;
9843   {
9844     try {
9845       result = (Dali::Radian *)new Dali::Radian(arg1);
9846     } catch (std::out_of_range& e) {
9847       {
9848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9849       };
9850     } catch (std::exception& e) {
9851       {
9852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9853       };
9854     } catch (Dali::DaliException e) {
9855       {
9856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9857       };
9858     } catch (...) {
9859       {
9860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9861       };
9862     }
9863   }
9864
9865   jresult = (void *)result;
9866   return jresult;
9867 }
9868
9869
9870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9871   void * jresult ;
9872   Dali::Degree arg1 ;
9873   Dali::Degree *argp1 ;
9874   Dali::Radian *result = 0 ;
9875
9876   argp1 = (Dali::Degree *)jarg1;
9877   if (!argp1) {
9878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9879     return 0;
9880   }
9881   arg1 = *argp1;
9882   {
9883     try {
9884       result = (Dali::Radian *)new Dali::Radian(arg1);
9885     } catch (std::out_of_range& e) {
9886       {
9887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9888       };
9889     } catch (std::exception& e) {
9890       {
9891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (Dali::DaliException e) {
9894       {
9895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9896       };
9897     } catch (...) {
9898       {
9899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9900       };
9901     }
9902   }
9903
9904   jresult = (void *)result;
9905   return jresult;
9906 }
9907
9908
9909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9910   void * jresult ;
9911   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9912   float arg2 ;
9913   Dali::Radian *result = 0 ;
9914
9915   arg1 = (Dali::Radian *)jarg1;
9916   arg2 = (float)jarg2;
9917   {
9918     try {
9919       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = (void *)result;
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9945   void * jresult ;
9946   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9947   Dali::Degree arg2 ;
9948   Dali::Degree *argp2 ;
9949   Dali::Radian *result = 0 ;
9950
9951   arg1 = (Dali::Radian *)jarg1;
9952   argp2 = (Dali::Degree *)jarg2;
9953   if (!argp2) {
9954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9955     return 0;
9956   }
9957   arg2 = *argp2;
9958   {
9959     try {
9960       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9961     } catch (std::out_of_range& e) {
9962       {
9963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9964       };
9965     } catch (std::exception& e) {
9966       {
9967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9968       };
9969     } catch (Dali::DaliException e) {
9970       {
9971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9972       };
9973     } catch (...) {
9974       {
9975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9976       };
9977     }
9978   }
9979
9980   jresult = (void *)result;
9981   return jresult;
9982 }
9983
9984
9985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9986   float jresult ;
9987   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9988   float result;
9989
9990   arg1 = (Dali::Radian *)jarg1;
9991   {
9992     try {
9993       result = (float)((Dali::Radian const *)arg1)->operator float();
9994     } catch (std::out_of_range& e) {
9995       {
9996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9997       };
9998     } catch (std::exception& e) {
9999       {
10000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10001       };
10002     } catch (Dali::DaliException e) {
10003       {
10004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10005       };
10006     } catch (...) {
10007       {
10008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10009       };
10010     }
10011   }
10012
10013   jresult = result;
10014   return jresult;
10015 }
10016
10017
10018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10019   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10020   float arg2 ;
10021
10022   arg1 = (Dali::Radian *)jarg1;
10023   arg2 = (float)jarg2;
10024   if (arg1) (arg1)->radian = arg2;
10025 }
10026
10027
10028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10029   float jresult ;
10030   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10031   float result;
10032
10033   arg1 = (Dali::Radian *)jarg1;
10034   result = (float) ((arg1)->radian);
10035   jresult = result;
10036   return jresult;
10037 }
10038
10039
10040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10041   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10042
10043   arg1 = (Dali::Radian *)jarg1;
10044   {
10045     try {
10046       delete arg1;
10047     } catch (std::out_of_range& e) {
10048       {
10049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10050       };
10051     } catch (std::exception& e) {
10052       {
10053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10054       };
10055     } catch (Dali::DaliException e) {
10056       {
10057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10058       };
10059     } catch (...) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10062       };
10063     }
10064   }
10065
10066 }
10067
10068
10069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10070   unsigned int jresult ;
10071   Dali::Radian arg1 ;
10072   Dali::Radian arg2 ;
10073   Dali::Radian *argp1 ;
10074   Dali::Radian *argp2 ;
10075   bool result;
10076
10077   argp1 = (Dali::Radian *)jarg1;
10078   if (!argp1) {
10079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10080     return 0;
10081   }
10082   arg1 = *argp1;
10083   argp2 = (Dali::Radian *)jarg2;
10084   if (!argp2) {
10085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10086     return 0;
10087   }
10088   arg2 = *argp2;
10089   {
10090     try {
10091       result = (bool)Dali::operator ==(arg1,arg2);
10092     } catch (std::out_of_range& e) {
10093       {
10094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10095       };
10096     } catch (std::exception& e) {
10097       {
10098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10099       };
10100     } catch (Dali::DaliException e) {
10101       {
10102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10103       };
10104     } catch (...) {
10105       {
10106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10107       };
10108     }
10109   }
10110
10111   jresult = result;
10112   return jresult;
10113 }
10114
10115
10116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10117   unsigned int jresult ;
10118   Dali::Radian arg1 ;
10119   Dali::Radian arg2 ;
10120   Dali::Radian *argp1 ;
10121   Dali::Radian *argp2 ;
10122   bool result;
10123
10124   argp1 = (Dali::Radian *)jarg1;
10125   if (!argp1) {
10126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10127     return 0;
10128   }
10129   arg1 = *argp1;
10130   argp2 = (Dali::Radian *)jarg2;
10131   if (!argp2) {
10132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10133     return 0;
10134   }
10135   arg2 = *argp2;
10136   {
10137     try {
10138       result = (bool)Dali::operator !=(arg1,arg2);
10139     } catch (std::out_of_range& e) {
10140       {
10141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10142       };
10143     } catch (std::exception& e) {
10144       {
10145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10146       };
10147     } catch (Dali::DaliException e) {
10148       {
10149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10150       };
10151     } catch (...) {
10152       {
10153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10154       };
10155     }
10156   }
10157
10158   jresult = result;
10159   return jresult;
10160 }
10161
10162
10163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10164   unsigned int jresult ;
10165   Dali::Radian arg1 ;
10166   Dali::Degree arg2 ;
10167   Dali::Radian *argp1 ;
10168   Dali::Degree *argp2 ;
10169   bool result;
10170
10171   argp1 = (Dali::Radian *)jarg1;
10172   if (!argp1) {
10173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10174     return 0;
10175   }
10176   arg1 = *argp1;
10177   argp2 = (Dali::Degree *)jarg2;
10178   if (!argp2) {
10179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10180     return 0;
10181   }
10182   arg2 = *argp2;
10183   {
10184     try {
10185       result = (bool)Dali::operator ==(arg1,arg2);
10186     } catch (std::out_of_range& e) {
10187       {
10188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10189       };
10190     } catch (std::exception& e) {
10191       {
10192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10193       };
10194     } catch (Dali::DaliException e) {
10195       {
10196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10197       };
10198     } catch (...) {
10199       {
10200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10201       };
10202     }
10203   }
10204
10205   jresult = result;
10206   return jresult;
10207 }
10208
10209
10210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10211   unsigned int jresult ;
10212   Dali::Radian arg1 ;
10213   Dali::Degree arg2 ;
10214   Dali::Radian *argp1 ;
10215   Dali::Degree *argp2 ;
10216   bool result;
10217
10218   argp1 = (Dali::Radian *)jarg1;
10219   if (!argp1) {
10220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10221     return 0;
10222   }
10223   arg1 = *argp1;
10224   argp2 = (Dali::Degree *)jarg2;
10225   if (!argp2) {
10226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10227     return 0;
10228   }
10229   arg2 = *argp2;
10230   {
10231     try {
10232       result = (bool)Dali::operator !=(arg1,arg2);
10233     } catch (std::out_of_range& e) {
10234       {
10235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (std::exception& e) {
10238       {
10239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10240       };
10241     } catch (Dali::DaliException e) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10244       };
10245     } catch (...) {
10246       {
10247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10248       };
10249     }
10250   }
10251
10252   jresult = result;
10253   return jresult;
10254 }
10255
10256
10257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10258   unsigned int jresult ;
10259   Dali::Degree arg1 ;
10260   Dali::Radian arg2 ;
10261   Dali::Degree *argp1 ;
10262   Dali::Radian *argp2 ;
10263   bool result;
10264
10265   argp1 = (Dali::Degree *)jarg1;
10266   if (!argp1) {
10267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10268     return 0;
10269   }
10270   arg1 = *argp1;
10271   argp2 = (Dali::Radian *)jarg2;
10272   if (!argp2) {
10273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10274     return 0;
10275   }
10276   arg2 = *argp2;
10277   {
10278     try {
10279       result = (bool)Dali::operator ==(arg1,arg2);
10280     } catch (std::out_of_range& e) {
10281       {
10282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (std::exception& e) {
10285       {
10286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10287       };
10288     } catch (Dali::DaliException e) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10291       };
10292     } catch (...) {
10293       {
10294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10295       };
10296     }
10297   }
10298
10299   jresult = result;
10300   return jresult;
10301 }
10302
10303
10304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10305   unsigned int jresult ;
10306   Dali::Degree arg1 ;
10307   Dali::Radian arg2 ;
10308   Dali::Degree *argp1 ;
10309   Dali::Radian *argp2 ;
10310   bool result;
10311
10312   argp1 = (Dali::Degree *)jarg1;
10313   if (!argp1) {
10314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10315     return 0;
10316   }
10317   arg1 = *argp1;
10318   argp2 = (Dali::Radian *)jarg2;
10319   if (!argp2) {
10320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10321     return 0;
10322   }
10323   arg2 = *argp2;
10324   {
10325     try {
10326       result = (bool)Dali::operator !=(arg1,arg2);
10327     } catch (std::out_of_range& e) {
10328       {
10329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (std::exception& e) {
10332       {
10333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10334       };
10335     } catch (Dali::DaliException e) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10338       };
10339     } catch (...) {
10340       {
10341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10342       };
10343     }
10344   }
10345
10346   jresult = result;
10347   return jresult;
10348 }
10349
10350
10351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10352   unsigned int jresult ;
10353   Dali::Radian arg1 ;
10354   Dali::Radian arg2 ;
10355   Dali::Radian *argp1 ;
10356   Dali::Radian *argp2 ;
10357   bool result;
10358
10359   argp1 = (Dali::Radian *)jarg1;
10360   if (!argp1) {
10361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10362     return 0;
10363   }
10364   arg1 = *argp1;
10365   argp2 = (Dali::Radian *)jarg2;
10366   if (!argp2) {
10367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10368     return 0;
10369   }
10370   arg2 = *argp2;
10371   {
10372     try {
10373       result = (bool)Dali::operator >(arg1,arg2);
10374     } catch (std::out_of_range& e) {
10375       {
10376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (std::exception& e) {
10379       {
10380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10381       };
10382     } catch (Dali::DaliException e) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10385       };
10386     } catch (...) {
10387       {
10388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10389       };
10390     }
10391   }
10392
10393   jresult = result;
10394   return jresult;
10395 }
10396
10397
10398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10399   unsigned int jresult ;
10400   Dali::Radian arg1 ;
10401   Dali::Degree arg2 ;
10402   Dali::Radian *argp1 ;
10403   Dali::Degree *argp2 ;
10404   bool result;
10405
10406   argp1 = (Dali::Radian *)jarg1;
10407   if (!argp1) {
10408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10409     return 0;
10410   }
10411   arg1 = *argp1;
10412   argp2 = (Dali::Degree *)jarg2;
10413   if (!argp2) {
10414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10415     return 0;
10416   }
10417   arg2 = *argp2;
10418   {
10419     try {
10420       result = (bool)Dali::operator >(arg1,arg2);
10421     } catch (std::out_of_range& e) {
10422       {
10423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (std::exception& e) {
10426       {
10427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10428       };
10429     } catch (Dali::DaliException e) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10432       };
10433     } catch (...) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10436       };
10437     }
10438   }
10439
10440   jresult = result;
10441   return jresult;
10442 }
10443
10444
10445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10446   unsigned int jresult ;
10447   Dali::Degree arg1 ;
10448   Dali::Radian arg2 ;
10449   Dali::Degree *argp1 ;
10450   Dali::Radian *argp2 ;
10451   bool result;
10452
10453   argp1 = (Dali::Degree *)jarg1;
10454   if (!argp1) {
10455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10456     return 0;
10457   }
10458   arg1 = *argp1;
10459   argp2 = (Dali::Radian *)jarg2;
10460   if (!argp2) {
10461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10462     return 0;
10463   }
10464   arg2 = *argp2;
10465   {
10466     try {
10467       result = (bool)Dali::operator >(arg1,arg2);
10468     } catch (std::out_of_range& e) {
10469       {
10470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (std::exception& e) {
10473       {
10474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10475       };
10476     } catch (Dali::DaliException e) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10479       };
10480     } catch (...) {
10481       {
10482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10483       };
10484     }
10485   }
10486
10487   jresult = result;
10488   return jresult;
10489 }
10490
10491
10492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10493   unsigned int jresult ;
10494   Dali::Radian arg1 ;
10495   Dali::Radian arg2 ;
10496   Dali::Radian *argp1 ;
10497   Dali::Radian *argp2 ;
10498   bool result;
10499
10500   argp1 = (Dali::Radian *)jarg1;
10501   if (!argp1) {
10502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10503     return 0;
10504   }
10505   arg1 = *argp1;
10506   argp2 = (Dali::Radian *)jarg2;
10507   if (!argp2) {
10508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10509     return 0;
10510   }
10511   arg2 = *argp2;
10512   {
10513     try {
10514       result = (bool)Dali::operator <(arg1,arg2);
10515     } catch (std::out_of_range& e) {
10516       {
10517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (std::exception& e) {
10520       {
10521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10522       };
10523     } catch (Dali::DaliException e) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10526       };
10527     } catch (...) {
10528       {
10529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10530       };
10531     }
10532   }
10533
10534   jresult = result;
10535   return jresult;
10536 }
10537
10538
10539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10540   unsigned int jresult ;
10541   Dali::Radian arg1 ;
10542   Dali::Degree arg2 ;
10543   Dali::Radian *argp1 ;
10544   Dali::Degree *argp2 ;
10545   bool result;
10546
10547   argp1 = (Dali::Radian *)jarg1;
10548   if (!argp1) {
10549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10550     return 0;
10551   }
10552   arg1 = *argp1;
10553   argp2 = (Dali::Degree *)jarg2;
10554   if (!argp2) {
10555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10556     return 0;
10557   }
10558   arg2 = *argp2;
10559   {
10560     try {
10561       result = (bool)Dali::operator <(arg1,arg2);
10562     } catch (std::out_of_range& e) {
10563       {
10564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (std::exception& e) {
10567       {
10568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10569       };
10570     } catch (Dali::DaliException e) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10573       };
10574     } catch (...) {
10575       {
10576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10577       };
10578     }
10579   }
10580
10581   jresult = result;
10582   return jresult;
10583 }
10584
10585
10586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10587   unsigned int jresult ;
10588   Dali::Degree arg1 ;
10589   Dali::Radian arg2 ;
10590   Dali::Degree *argp1 ;
10591   Dali::Radian *argp2 ;
10592   bool result;
10593
10594   argp1 = (Dali::Degree *)jarg1;
10595   if (!argp1) {
10596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10597     return 0;
10598   }
10599   arg1 = *argp1;
10600   argp2 = (Dali::Radian *)jarg2;
10601   if (!argp2) {
10602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10603     return 0;
10604   }
10605   arg2 = *argp2;
10606   {
10607     try {
10608       result = (bool)Dali::operator <(arg1,arg2);
10609     } catch (std::out_of_range& e) {
10610       {
10611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (std::exception& e) {
10614       {
10615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10616       };
10617     } catch (Dali::DaliException e) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10620       };
10621     } catch (...) {
10622       {
10623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10624       };
10625     }
10626   }
10627
10628   jresult = result;
10629   return jresult;
10630 }
10631
10632
10633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10634   void * jresult ;
10635   Dali::Radian arg1 ;
10636   float arg2 ;
10637   Dali::Radian *argp1 ;
10638   Dali::Radian result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   arg2 = (float)jarg2;
10647   {
10648     try {
10649       result = Dali::operator *(arg1,arg2);
10650     } catch (std::out_of_range& e) {
10651       {
10652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10653       };
10654     } catch (std::exception& e) {
10655       {
10656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (Dali::DaliException e) {
10659       {
10660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10661       };
10662     } catch (...) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10665       };
10666     }
10667   }
10668
10669   jresult = new Dali::Radian((const Dali::Radian &)result);
10670   return jresult;
10671 }
10672
10673
10674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10675   void * jresult ;
10676   Dali::Radian arg1 ;
10677   Dali::Radian *argp1 ;
10678   Dali::Radian result;
10679
10680   argp1 = (Dali::Radian *)jarg1;
10681   if (!argp1) {
10682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10683     return 0;
10684   }
10685   arg1 = *argp1;
10686   {
10687     try {
10688       result = Dali::operator -(arg1);
10689     } catch (std::out_of_range& e) {
10690       {
10691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10692       };
10693     } catch (std::exception& e) {
10694       {
10695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10696       };
10697     } catch (Dali::DaliException e) {
10698       {
10699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10700       };
10701     } catch (...) {
10702       {
10703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10704       };
10705     }
10706   }
10707
10708   jresult = new Dali::Radian((const Dali::Radian &)result);
10709   return jresult;
10710 }
10711
10712
10713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10714   void * jresult ;
10715   Dali::Radian arg1 ;
10716   float arg2 ;
10717   float arg3 ;
10718   Dali::Radian *argp1 ;
10719   Dali::Radian result;
10720
10721   argp1 = (Dali::Radian *)jarg1;
10722   if (!argp1) {
10723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10724     return 0;
10725   }
10726   arg1 = *argp1;
10727   arg2 = (float)jarg2;
10728   arg3 = (float)jarg3;
10729   {
10730     try {
10731       result = Dali::Clamp(arg1,arg2,arg3);
10732     } catch (std::out_of_range& e) {
10733       {
10734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10735       };
10736     } catch (std::exception& e) {
10737       {
10738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (Dali::DaliException e) {
10741       {
10742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10743       };
10744     } catch (...) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10747       };
10748     }
10749   }
10750
10751   jresult = new Dali::Radian((const Dali::Radian &)result);
10752   return jresult;
10753 }
10754
10755
10756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10757   void * jresult ;
10758   Dali::Quaternion *result = 0 ;
10759
10760   {
10761     try {
10762       result = (Dali::Quaternion *)new Dali::Quaternion();
10763     } catch (std::out_of_range& e) {
10764       {
10765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10766       };
10767     } catch (std::exception& e) {
10768       {
10769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10770       };
10771     } catch (Dali::DaliException e) {
10772       {
10773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10774       };
10775     } catch (...) {
10776       {
10777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10778       };
10779     }
10780   }
10781
10782   jresult = (void *)result;
10783   return jresult;
10784 }
10785
10786
10787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10788   void * jresult ;
10789   Dali::Radian arg1 ;
10790   Dali::Vector3 *arg2 = 0 ;
10791   Dali::Radian *argp1 ;
10792   Dali::Quaternion *result = 0 ;
10793
10794   argp1 = (Dali::Radian *)jarg1;
10795   if (!argp1) {
10796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10797     return 0;
10798   }
10799   arg1 = *argp1;
10800   arg2 = (Dali::Vector3 *)jarg2;
10801   if (!arg2) {
10802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10803     return 0;
10804   }
10805   {
10806     try {
10807       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10808     } catch (std::out_of_range& e) {
10809       {
10810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10811       };
10812     } catch (std::exception& e) {
10813       {
10814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10815       };
10816     } catch (Dali::DaliException e) {
10817       {
10818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10819       };
10820     } catch (...) {
10821       {
10822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10823       };
10824     }
10825   }
10826
10827   jresult = (void *)result;
10828   return jresult;
10829 }
10830
10831
10832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10833   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10834
10835   arg1 = (Dali::Quaternion *)jarg1;
10836   {
10837     try {
10838       delete arg1;
10839     } catch (std::out_of_range& e) {
10840       {
10841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10842       };
10843     } catch (std::exception& e) {
10844       {
10845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10846       };
10847     } catch (Dali::DaliException e) {
10848       {
10849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10850       };
10851     } catch (...) {
10852       {
10853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10854       };
10855     }
10856   }
10857
10858 }
10859
10860
10861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10862   void * jresult ;
10863   Dali::Quaternion *result = 0 ;
10864
10865   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10866   jresult = (void *)result;
10867   return jresult;
10868 }
10869
10870
10871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10872   unsigned int jresult ;
10873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10874   bool result;
10875
10876   arg1 = (Dali::Quaternion *)jarg1;
10877   {
10878     try {
10879       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10880     } catch (std::out_of_range& e) {
10881       {
10882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10883       };
10884     } catch (std::exception& e) {
10885       {
10886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10887       };
10888     } catch (Dali::DaliException e) {
10889       {
10890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10891       };
10892     } catch (...) {
10893       {
10894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10895       };
10896     }
10897   }
10898
10899   jresult = result;
10900   return jresult;
10901 }
10902
10903
10904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10905   unsigned int jresult ;
10906   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10907   Dali::Vector3 *arg2 = 0 ;
10908   Dali::Radian *arg3 = 0 ;
10909   bool result;
10910
10911   arg1 = (Dali::Quaternion *)jarg1;
10912   arg2 = (Dali::Vector3 *)jarg2;
10913   if (!arg2) {
10914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10915     return 0;
10916   }
10917   arg3 = (Dali::Radian *)jarg3;
10918   if (!arg3) {
10919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
10920     return 0;
10921   }
10922   {
10923     try {
10924       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
10925     } catch (std::out_of_range& e) {
10926       {
10927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10928       };
10929     } catch (std::exception& e) {
10930       {
10931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10932       };
10933     } catch (Dali::DaliException e) {
10934       {
10935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10936       };
10937     } catch (...) {
10938       {
10939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10940       };
10941     }
10942   }
10943
10944   jresult = result;
10945   return jresult;
10946 }
10947
10948
10949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
10950   void * jresult ;
10951   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10952   Dali::Quaternion *arg2 = 0 ;
10953   Dali::Quaternion result;
10954
10955   arg1 = (Dali::Quaternion *)jarg1;
10956   arg2 = (Dali::Quaternion *)jarg2;
10957   if (!arg2) {
10958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10959     return 0;
10960   }
10961   {
10962     try {
10963       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10964     } catch (std::out_of_range& e) {
10965       {
10966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10967       };
10968     } catch (std::exception& e) {
10969       {
10970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (Dali::DaliException e) {
10973       {
10974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10975       };
10976     } catch (...) {
10977       {
10978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10979       };
10980     }
10981   }
10982
10983   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10984   return jresult;
10985 }
10986
10987
10988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10989   void * jresult ;
10990   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10991   Dali::Quaternion *arg2 = 0 ;
10992   Dali::Quaternion result;
10993
10994   arg1 = (Dali::Quaternion *)jarg1;
10995   arg2 = (Dali::Quaternion *)jarg2;
10996   if (!arg2) {
10997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10998     return 0;
10999   }
11000   {
11001     try {
11002       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11003     } catch (std::out_of_range& e) {
11004       {
11005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11006       };
11007     } catch (std::exception& e) {
11008       {
11009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11010       };
11011     } catch (Dali::DaliException e) {
11012       {
11013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11014       };
11015     } catch (...) {
11016       {
11017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11018       };
11019     }
11020   }
11021
11022   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11023   return jresult;
11024 }
11025
11026
11027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11028   void * jresult ;
11029   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11030   Dali::Quaternion *arg2 = 0 ;
11031   Dali::Quaternion result;
11032
11033   arg1 = (Dali::Quaternion *)jarg1;
11034   arg2 = (Dali::Quaternion *)jarg2;
11035   if (!arg2) {
11036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11037     return 0;
11038   }
11039   {
11040     try {
11041       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11042     } catch (std::out_of_range& e) {
11043       {
11044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11045       };
11046     } catch (std::exception& e) {
11047       {
11048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11049       };
11050     } catch (Dali::DaliException e) {
11051       {
11052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11053       };
11054     } catch (...) {
11055       {
11056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11057       };
11058     }
11059   }
11060
11061   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11062   return jresult;
11063 }
11064
11065
11066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11067   void * jresult ;
11068   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11069   Dali::Vector3 *arg2 = 0 ;
11070   Dali::Vector3 result;
11071
11072   arg1 = (Dali::Quaternion *)jarg1;
11073   arg2 = (Dali::Vector3 *)jarg2;
11074   if (!arg2) {
11075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11076     return 0;
11077   }
11078   {
11079     try {
11080       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11081     } catch (std::out_of_range& e) {
11082       {
11083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11084       };
11085     } catch (std::exception& e) {
11086       {
11087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11088       };
11089     } catch (Dali::DaliException e) {
11090       {
11091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11092       };
11093     } catch (...) {
11094       {
11095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11096       };
11097     }
11098   }
11099
11100   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11101   return jresult;
11102 }
11103
11104
11105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11106   void * jresult ;
11107   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11108   Dali::Quaternion *arg2 = 0 ;
11109   Dali::Quaternion result;
11110
11111   arg1 = (Dali::Quaternion *)jarg1;
11112   arg2 = (Dali::Quaternion *)jarg2;
11113   if (!arg2) {
11114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11115     return 0;
11116   }
11117   {
11118     try {
11119       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11120     } catch (std::out_of_range& e) {
11121       {
11122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11123       };
11124     } catch (std::exception& e) {
11125       {
11126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11127       };
11128     } catch (Dali::DaliException e) {
11129       {
11130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11131       };
11132     } catch (...) {
11133       {
11134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11135       };
11136     }
11137   }
11138
11139   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11140   return jresult;
11141 }
11142
11143
11144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11145   void * jresult ;
11146   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11147   float arg2 ;
11148   Dali::Quaternion result;
11149
11150   arg1 = (Dali::Quaternion *)jarg1;
11151   arg2 = (float)jarg2;
11152   {
11153     try {
11154       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11155     } catch (std::out_of_range& e) {
11156       {
11157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11158       };
11159     } catch (std::exception& e) {
11160       {
11161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11162       };
11163     } catch (Dali::DaliException e) {
11164       {
11165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11166       };
11167     } catch (...) {
11168       {
11169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11170       };
11171     }
11172   }
11173
11174   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11175   return jresult;
11176 }
11177
11178
11179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11180   void * jresult ;
11181   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11182   float arg2 ;
11183   Dali::Quaternion result;
11184
11185   arg1 = (Dali::Quaternion *)jarg1;
11186   arg2 = (float)jarg2;
11187   {
11188     try {
11189       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11190     } catch (std::out_of_range& e) {
11191       {
11192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11193       };
11194     } catch (std::exception& e) {
11195       {
11196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11197       };
11198     } catch (Dali::DaliException e) {
11199       {
11200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11201       };
11202     } catch (...) {
11203       {
11204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11205       };
11206     }
11207   }
11208
11209   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11210   return jresult;
11211 }
11212
11213
11214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11215   void * jresult ;
11216   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11217   Dali::Quaternion result;
11218
11219   arg1 = (Dali::Quaternion *)jarg1;
11220   {
11221     try {
11222       result = ((Dali::Quaternion const *)arg1)->operator -();
11223     } catch (std::out_of_range& e) {
11224       {
11225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (std::exception& e) {
11228       {
11229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11230       };
11231     } catch (Dali::DaliException e) {
11232       {
11233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11234       };
11235     } catch (...) {
11236       {
11237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11238       };
11239     }
11240   }
11241
11242   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11243   return jresult;
11244 }
11245
11246
11247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11248   void * jresult ;
11249   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11250   Dali::Quaternion *arg2 = 0 ;
11251   Dali::Quaternion *result = 0 ;
11252
11253   arg1 = (Dali::Quaternion *)jarg1;
11254   arg2 = (Dali::Quaternion *)jarg2;
11255   if (!arg2) {
11256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11257     return 0;
11258   }
11259   {
11260     try {
11261       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11262     } catch (std::out_of_range& e) {
11263       {
11264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (std::exception& e) {
11267       {
11268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11269       };
11270     } catch (Dali::DaliException e) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11273       };
11274     } catch (...) {
11275       {
11276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11277       };
11278     }
11279   }
11280
11281   jresult = (void *)result;
11282   return jresult;
11283 }
11284
11285
11286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11287   void * jresult ;
11288   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11289   Dali::Quaternion *arg2 = 0 ;
11290   Dali::Quaternion *result = 0 ;
11291
11292   arg1 = (Dali::Quaternion *)jarg1;
11293   arg2 = (Dali::Quaternion *)jarg2;
11294   if (!arg2) {
11295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11296     return 0;
11297   }
11298   {
11299     try {
11300       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11301     } catch (std::out_of_range& e) {
11302       {
11303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11304       };
11305     } catch (std::exception& e) {
11306       {
11307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11308       };
11309     } catch (Dali::DaliException e) {
11310       {
11311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11312       };
11313     } catch (...) {
11314       {
11315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11316       };
11317     }
11318   }
11319
11320   jresult = (void *)result;
11321   return jresult;
11322 }
11323
11324
11325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11326   void * jresult ;
11327   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11328   Dali::Quaternion *arg2 = 0 ;
11329   Dali::Quaternion *result = 0 ;
11330
11331   arg1 = (Dali::Quaternion *)jarg1;
11332   arg2 = (Dali::Quaternion *)jarg2;
11333   if (!arg2) {
11334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11335     return 0;
11336   }
11337   {
11338     try {
11339       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11340     } catch (std::out_of_range& e) {
11341       {
11342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11343       };
11344     } catch (std::exception& e) {
11345       {
11346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11347       };
11348     } catch (Dali::DaliException e) {
11349       {
11350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11351       };
11352     } catch (...) {
11353       {
11354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11355       };
11356     }
11357   }
11358
11359   jresult = (void *)result;
11360   return jresult;
11361 }
11362
11363
11364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11365   void * jresult ;
11366   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11367   float arg2 ;
11368   Dali::Quaternion *result = 0 ;
11369
11370   arg1 = (Dali::Quaternion *)jarg1;
11371   arg2 = (float)jarg2;
11372   {
11373     try {
11374       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11375     } catch (std::out_of_range& e) {
11376       {
11377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11378       };
11379     } catch (std::exception& e) {
11380       {
11381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11382       };
11383     } catch (Dali::DaliException e) {
11384       {
11385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11386       };
11387     } catch (...) {
11388       {
11389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11390       };
11391     }
11392   }
11393
11394   jresult = (void *)result;
11395   return jresult;
11396 }
11397
11398
11399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11400   void * jresult ;
11401   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11402   float arg2 ;
11403   Dali::Quaternion *result = 0 ;
11404
11405   arg1 = (Dali::Quaternion *)jarg1;
11406   arg2 = (float)jarg2;
11407   {
11408     try {
11409       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11410     } catch (std::out_of_range& e) {
11411       {
11412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11413       };
11414     } catch (std::exception& e) {
11415       {
11416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11417       };
11418     } catch (Dali::DaliException e) {
11419       {
11420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11421       };
11422     } catch (...) {
11423       {
11424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11425       };
11426     }
11427   }
11428
11429   jresult = (void *)result;
11430   return jresult;
11431 }
11432
11433
11434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11435   unsigned int jresult ;
11436   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11437   Dali::Quaternion *arg2 = 0 ;
11438   bool result;
11439
11440   arg1 = (Dali::Quaternion *)jarg1;
11441   arg2 = (Dali::Quaternion *)jarg2;
11442   if (!arg2) {
11443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11444     return 0;
11445   }
11446   {
11447     try {
11448       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11449     } catch (std::out_of_range& e) {
11450       {
11451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11452       };
11453     } catch (std::exception& e) {
11454       {
11455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11456       };
11457     } catch (Dali::DaliException e) {
11458       {
11459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11460       };
11461     } catch (...) {
11462       {
11463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11464       };
11465     }
11466   }
11467
11468   jresult = result;
11469   return jresult;
11470 }
11471
11472
11473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11474   unsigned int jresult ;
11475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11476   Dali::Quaternion *arg2 = 0 ;
11477   bool result;
11478
11479   arg1 = (Dali::Quaternion *)jarg1;
11480   arg2 = (Dali::Quaternion *)jarg2;
11481   if (!arg2) {
11482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11483     return 0;
11484   }
11485   {
11486     try {
11487       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11488     } catch (std::out_of_range& e) {
11489       {
11490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11491       };
11492     } catch (std::exception& e) {
11493       {
11494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11495       };
11496     } catch (Dali::DaliException e) {
11497       {
11498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11499       };
11500     } catch (...) {
11501       {
11502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11503       };
11504     }
11505   }
11506
11507   jresult = result;
11508   return jresult;
11509 }
11510
11511
11512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11513   float jresult ;
11514   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11515   float result;
11516
11517   arg1 = (Dali::Quaternion *)jarg1;
11518   {
11519     try {
11520       result = (float)((Dali::Quaternion const *)arg1)->Length();
11521     } catch (std::out_of_range& e) {
11522       {
11523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11524       };
11525     } catch (std::exception& e) {
11526       {
11527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11528       };
11529     } catch (Dali::DaliException e) {
11530       {
11531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11532       };
11533     } catch (...) {
11534       {
11535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11536       };
11537     }
11538   }
11539
11540   jresult = result;
11541   return jresult;
11542 }
11543
11544
11545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11546   float jresult ;
11547   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11548   float result;
11549
11550   arg1 = (Dali::Quaternion *)jarg1;
11551   {
11552     try {
11553       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11554     } catch (std::out_of_range& e) {
11555       {
11556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (std::exception& e) {
11559       {
11560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11561       };
11562     } catch (Dali::DaliException e) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11565       };
11566     } catch (...) {
11567       {
11568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11569       };
11570     }
11571   }
11572
11573   jresult = result;
11574   return jresult;
11575 }
11576
11577
11578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11579   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11580
11581   arg1 = (Dali::Quaternion *)jarg1;
11582   {
11583     try {
11584       (arg1)->Normalize();
11585     } catch (std::out_of_range& e) {
11586       {
11587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11588       };
11589     } catch (std::exception& e) {
11590       {
11591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11592       };
11593     } catch (Dali::DaliException e) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11596       };
11597     } catch (...) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11600       };
11601     }
11602   }
11603
11604 }
11605
11606
11607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11608   void * jresult ;
11609   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11610   Dali::Quaternion result;
11611
11612   arg1 = (Dali::Quaternion *)jarg1;
11613   {
11614     try {
11615       result = ((Dali::Quaternion const *)arg1)->Normalized();
11616     } catch (std::out_of_range& e) {
11617       {
11618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11619       };
11620     } catch (std::exception& e) {
11621       {
11622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11623       };
11624     } catch (Dali::DaliException e) {
11625       {
11626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11627       };
11628     } catch (...) {
11629       {
11630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11631       };
11632     }
11633   }
11634
11635   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11636   return jresult;
11637 }
11638
11639
11640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11641   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11642
11643   arg1 = (Dali::Quaternion *)jarg1;
11644   {
11645     try {
11646       (arg1)->Conjugate();
11647     } catch (std::out_of_range& e) {
11648       {
11649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11650       };
11651     } catch (std::exception& e) {
11652       {
11653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11654       };
11655     } catch (Dali::DaliException e) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11658       };
11659     } catch (...) {
11660       {
11661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11662       };
11663     }
11664   }
11665
11666 }
11667
11668
11669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11670   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11671
11672   arg1 = (Dali::Quaternion *)jarg1;
11673   {
11674     try {
11675       (arg1)->Invert();
11676     } catch (std::out_of_range& e) {
11677       {
11678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11679       };
11680     } catch (std::exception& e) {
11681       {
11682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11683       };
11684     } catch (Dali::DaliException e) {
11685       {
11686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11687       };
11688     } catch (...) {
11689       {
11690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11691       };
11692     }
11693   }
11694
11695 }
11696
11697
11698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11699   void * jresult ;
11700   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11701   Dali::Quaternion result;
11702
11703   arg1 = (Dali::Quaternion *)jarg1;
11704   {
11705     try {
11706       result = ((Dali::Quaternion const *)arg1)->Log();
11707     } catch (std::out_of_range& e) {
11708       {
11709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11710       };
11711     } catch (std::exception& e) {
11712       {
11713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11714       };
11715     } catch (Dali::DaliException e) {
11716       {
11717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11718       };
11719     } catch (...) {
11720       {
11721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11722       };
11723     }
11724   }
11725
11726   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11727   return jresult;
11728 }
11729
11730
11731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11732   void * jresult ;
11733   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11734   Dali::Quaternion result;
11735
11736   arg1 = (Dali::Quaternion *)jarg1;
11737   {
11738     try {
11739       result = ((Dali::Quaternion const *)arg1)->Exp();
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11747       };
11748     } catch (Dali::DaliException e) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11755       };
11756     }
11757   }
11758
11759   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11760   return jresult;
11761 }
11762
11763
11764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11765   float jresult ;
11766   Dali::Quaternion *arg1 = 0 ;
11767   Dali::Quaternion *arg2 = 0 ;
11768   float result;
11769
11770   arg1 = (Dali::Quaternion *)jarg1;
11771   if (!arg1) {
11772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11773     return 0;
11774   }
11775   arg2 = (Dali::Quaternion *)jarg2;
11776   if (!arg2) {
11777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11778     return 0;
11779   }
11780   {
11781     try {
11782       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11783     } catch (std::out_of_range& e) {
11784       {
11785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11786       };
11787     } catch (std::exception& e) {
11788       {
11789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11790       };
11791     } catch (Dali::DaliException e) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11794       };
11795     } catch (...) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11798       };
11799     }
11800   }
11801
11802   jresult = result;
11803   return jresult;
11804 }
11805
11806
11807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11808   void * jresult ;
11809   Dali::Quaternion *arg1 = 0 ;
11810   Dali::Quaternion *arg2 = 0 ;
11811   float arg3 ;
11812   Dali::Quaternion result;
11813
11814   arg1 = (Dali::Quaternion *)jarg1;
11815   if (!arg1) {
11816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11817     return 0;
11818   }
11819   arg2 = (Dali::Quaternion *)jarg2;
11820   if (!arg2) {
11821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11822     return 0;
11823   }
11824   arg3 = (float)jarg3;
11825   {
11826     try {
11827       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11828     } catch (std::out_of_range& e) {
11829       {
11830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11831       };
11832     } catch (std::exception& e) {
11833       {
11834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11835       };
11836     } catch (Dali::DaliException e) {
11837       {
11838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11839       };
11840     } catch (...) {
11841       {
11842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11843       };
11844     }
11845   }
11846
11847   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11848   return jresult;
11849 }
11850
11851
11852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11853   void * jresult ;
11854   Dali::Quaternion *arg1 = 0 ;
11855   Dali::Quaternion *arg2 = 0 ;
11856   float arg3 ;
11857   Dali::Quaternion result;
11858
11859   arg1 = (Dali::Quaternion *)jarg1;
11860   if (!arg1) {
11861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11862     return 0;
11863   }
11864   arg2 = (Dali::Quaternion *)jarg2;
11865   if (!arg2) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11867     return 0;
11868   }
11869   arg3 = (float)jarg3;
11870   {
11871     try {
11872       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11873     } catch (std::out_of_range& e) {
11874       {
11875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11876       };
11877     } catch (std::exception& e) {
11878       {
11879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (Dali::DaliException e) {
11882       {
11883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11884       };
11885     } catch (...) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11888       };
11889     }
11890   }
11891
11892   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11893   return jresult;
11894 }
11895
11896
11897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11898   void * jresult ;
11899   Dali::Quaternion *arg1 = 0 ;
11900   Dali::Quaternion *arg2 = 0 ;
11901   float arg3 ;
11902   Dali::Quaternion result;
11903
11904   arg1 = (Dali::Quaternion *)jarg1;
11905   if (!arg1) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11907     return 0;
11908   }
11909   arg2 = (Dali::Quaternion *)jarg2;
11910   if (!arg2) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11912     return 0;
11913   }
11914   arg3 = (float)jarg3;
11915   {
11916     try {
11917       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (Dali::DaliException e) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11929       };
11930     } catch (...) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11933       };
11934     }
11935   }
11936
11937   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11938   return jresult;
11939 }
11940
11941
11942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
11943   void * jresult ;
11944   Dali::Quaternion *arg1 = 0 ;
11945   Dali::Quaternion *arg2 = 0 ;
11946   Dali::Quaternion *arg3 = 0 ;
11947   Dali::Quaternion *arg4 = 0 ;
11948   float arg5 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (Dali::Quaternion *)jarg3;
11962   if (!arg3) {
11963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11964     return 0;
11965   }
11966   arg4 = (Dali::Quaternion *)jarg4;
11967   if (!arg4) {
11968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11969     return 0;
11970   }
11971   arg5 = (float)jarg5;
11972   {
11973     try {
11974       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11975     } catch (std::out_of_range& e) {
11976       {
11977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11978       };
11979     } catch (std::exception& e) {
11980       {
11981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11982       };
11983     } catch (Dali::DaliException e) {
11984       {
11985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11986       };
11987     } catch (...) {
11988       {
11989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11990       };
11991     }
11992   }
11993
11994   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12000   float jresult ;
12001   Dali::Quaternion *arg1 = 0 ;
12002   Dali::Quaternion *arg2 = 0 ;
12003   float result;
12004
12005   arg1 = (Dali::Quaternion *)jarg1;
12006   if (!arg1) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12008     return 0;
12009   }
12010   arg2 = (Dali::Quaternion *)jarg2;
12011   if (!arg2) {
12012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12013     return 0;
12014   }
12015   {
12016     try {
12017       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12018     } catch (std::out_of_range& e) {
12019       {
12020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12021       };
12022     } catch (std::exception& e) {
12023       {
12024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12025       };
12026     } catch (Dali::DaliException e) {
12027       {
12028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12029       };
12030     } catch (...) {
12031       {
12032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12033       };
12034     }
12035   }
12036
12037   jresult = result;
12038   return jresult;
12039 }
12040
12041
12042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12043   void * jresult ;
12044   Dali::Matrix *result = 0 ;
12045
12046   {
12047     try {
12048       result = (Dali::Matrix *)new Dali::Matrix();
12049     } catch (std::out_of_range& e) {
12050       {
12051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12052       };
12053     } catch (std::exception& e) {
12054       {
12055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12056       };
12057     } catch (Dali::DaliException e) {
12058       {
12059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12060       };
12061     } catch (...) {
12062       {
12063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12064       };
12065     }
12066   }
12067
12068   jresult = (void *)result;
12069   return jresult;
12070 }
12071
12072
12073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12074   void * jresult ;
12075   bool arg1 ;
12076   Dali::Matrix *result = 0 ;
12077
12078   arg1 = jarg1 ? true : false;
12079   {
12080     try {
12081       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12082     } catch (std::out_of_range& e) {
12083       {
12084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (std::exception& e) {
12087       {
12088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12089       };
12090     } catch (Dali::DaliException e) {
12091       {
12092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12093       };
12094     } catch (...) {
12095       {
12096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12097       };
12098     }
12099   }
12100
12101   jresult = (void *)result;
12102   return jresult;
12103 }
12104
12105
12106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12107   void * jresult ;
12108   float *arg1 = (float *) 0 ;
12109   Dali::Matrix *result = 0 ;
12110
12111   arg1 = jarg1;
12112   {
12113     try {
12114       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = (void *)result;
12135
12136
12137   return jresult;
12138 }
12139
12140
12141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12142   void * jresult ;
12143   Dali::Quaternion *arg1 = 0 ;
12144   Dali::Matrix *result = 0 ;
12145
12146   arg1 = (Dali::Quaternion *)jarg1;
12147   if (!arg1) {
12148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12149     return 0;
12150   }
12151   {
12152     try {
12153       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12154     } catch (std::out_of_range& e) {
12155       {
12156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12157       };
12158     } catch (std::exception& e) {
12159       {
12160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (Dali::DaliException e) {
12163       {
12164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12165       };
12166     } catch (...) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12169       };
12170     }
12171   }
12172
12173   jresult = (void *)result;
12174   return jresult;
12175 }
12176
12177
12178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12179   void * jresult ;
12180   Dali::Matrix *arg1 = 0 ;
12181   Dali::Matrix *result = 0 ;
12182
12183   arg1 = (Dali::Matrix *)jarg1;
12184   if (!arg1) {
12185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12186     return 0;
12187   }
12188   {
12189     try {
12190       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12191     } catch (std::out_of_range& e) {
12192       {
12193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (std::exception& e) {
12196       {
12197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12198       };
12199     } catch (Dali::DaliException e) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12202       };
12203     } catch (...) {
12204       {
12205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12206       };
12207     }
12208   }
12209
12210   jresult = (void *)result;
12211   return jresult;
12212 }
12213
12214
12215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12216   void * jresult ;
12217   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12218   Dali::Matrix *arg2 = 0 ;
12219   Dali::Matrix *result = 0 ;
12220
12221   arg1 = (Dali::Matrix *)jarg1;
12222   arg2 = (Dali::Matrix *)jarg2;
12223   if (!arg2) {
12224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12225     return 0;
12226   }
12227   {
12228     try {
12229       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12230     } catch (std::out_of_range& e) {
12231       {
12232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12233       };
12234     } catch (std::exception& e) {
12235       {
12236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12237       };
12238     } catch (Dali::DaliException e) {
12239       {
12240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12241       };
12242     } catch (...) {
12243       {
12244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12245       };
12246     }
12247   }
12248
12249   jresult = (void *)result;
12250   return jresult;
12251 }
12252
12253
12254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12255   void * jresult ;
12256   Dali::Matrix *result = 0 ;
12257
12258   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12259   jresult = (void *)result;
12260   return jresult;
12261 }
12262
12263
12264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12265   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12266
12267   arg1 = (Dali::Matrix *)jarg1;
12268   {
12269     try {
12270       (arg1)->SetIdentity();
12271     } catch (std::out_of_range& e) {
12272       {
12273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12274       };
12275     } catch (std::exception& e) {
12276       {
12277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12278       };
12279     } catch (Dali::DaliException e) {
12280       {
12281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12282       };
12283     } catch (...) {
12284       {
12285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12286       };
12287     }
12288   }
12289
12290 }
12291
12292
12293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12294   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12295   Dali::Vector3 *arg2 = 0 ;
12296
12297   arg1 = (Dali::Matrix *)jarg1;
12298   arg2 = (Dali::Vector3 *)jarg2;
12299   if (!arg2) {
12300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12301     return ;
12302   }
12303   {
12304     try {
12305       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12306     } catch (std::out_of_range& e) {
12307       {
12308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12309       };
12310     } catch (std::exception& e) {
12311       {
12312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12313       };
12314     } catch (Dali::DaliException e) {
12315       {
12316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12317       };
12318     } catch (...) {
12319       {
12320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12321       };
12322     }
12323   }
12324
12325 }
12326
12327
12328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12329   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12330   Dali::Matrix *arg2 = 0 ;
12331
12332   arg1 = (Dali::Matrix *)jarg1;
12333   arg2 = (Dali::Matrix *)jarg2;
12334   if (!arg2) {
12335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12336     return ;
12337   }
12338   {
12339     try {
12340       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12341     } catch (std::out_of_range& e) {
12342       {
12343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12344       };
12345     } catch (std::exception& e) {
12346       {
12347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12348       };
12349     } catch (Dali::DaliException e) {
12350       {
12351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12352       };
12353     } catch (...) {
12354       {
12355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12356       };
12357     }
12358   }
12359
12360 }
12361
12362
12363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12364   unsigned int jresult ;
12365   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12366   bool result;
12367
12368   arg1 = (Dali::Matrix *)jarg1;
12369   {
12370     try {
12371       result = (bool)(arg1)->Invert();
12372     } catch (std::out_of_range& e) {
12373       {
12374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12375       };
12376     } catch (std::exception& e) {
12377       {
12378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12379       };
12380     } catch (Dali::DaliException e) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12383       };
12384     } catch (...) {
12385       {
12386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12387       };
12388     }
12389   }
12390
12391   jresult = result;
12392   return jresult;
12393 }
12394
12395
12396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12397   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12398
12399   arg1 = (Dali::Matrix *)jarg1;
12400   {
12401     try {
12402       (arg1)->Transpose();
12403     } catch (std::out_of_range& e) {
12404       {
12405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12406       };
12407     } catch (std::exception& e) {
12408       {
12409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12410       };
12411     } catch (Dali::DaliException e) {
12412       {
12413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12414       };
12415     } catch (...) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12418       };
12419     }
12420   }
12421
12422 }
12423
12424
12425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12426   void * jresult ;
12427   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12428   Dali::Vector3 result;
12429
12430   arg1 = (Dali::Matrix *)jarg1;
12431   {
12432     try {
12433       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12434     } catch (std::out_of_range& e) {
12435       {
12436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12437       };
12438     } catch (std::exception& e) {
12439       {
12440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12441       };
12442     } catch (Dali::DaliException e) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12445       };
12446     } catch (...) {
12447       {
12448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12449       };
12450     }
12451   }
12452
12453   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12454   return jresult;
12455 }
12456
12457
12458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12459   void * jresult ;
12460   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12461   Dali::Vector3 result;
12462
12463   arg1 = (Dali::Matrix *)jarg1;
12464   {
12465     try {
12466       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12467     } catch (std::out_of_range& e) {
12468       {
12469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12470       };
12471     } catch (std::exception& e) {
12472       {
12473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12474       };
12475     } catch (Dali::DaliException e) {
12476       {
12477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12478       };
12479     } catch (...) {
12480       {
12481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12482       };
12483     }
12484   }
12485
12486   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12487   return jresult;
12488 }
12489
12490
12491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12492   void * jresult ;
12493   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12494   Dali::Vector3 result;
12495
12496   arg1 = (Dali::Matrix *)jarg1;
12497   {
12498     try {
12499       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12500     } catch (std::out_of_range& e) {
12501       {
12502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (std::exception& e) {
12505       {
12506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (Dali::DaliException e) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12511       };
12512     } catch (...) {
12513       {
12514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12515       };
12516     }
12517   }
12518
12519   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12520   return jresult;
12521 }
12522
12523
12524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12525   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12526   Dali::Vector3 *arg2 = 0 ;
12527
12528   arg1 = (Dali::Matrix *)jarg1;
12529   arg2 = (Dali::Vector3 *)jarg2;
12530   if (!arg2) {
12531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12532     return ;
12533   }
12534   {
12535     try {
12536       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12537     } catch (std::out_of_range& e) {
12538       {
12539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12540       };
12541     } catch (std::exception& e) {
12542       {
12543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (Dali::DaliException e) {
12546       {
12547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12548       };
12549     } catch (...) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12552       };
12553     }
12554   }
12555
12556 }
12557
12558
12559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12560   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12561   Dali::Vector3 *arg2 = 0 ;
12562
12563   arg1 = (Dali::Matrix *)jarg1;
12564   arg2 = (Dali::Vector3 *)jarg2;
12565   if (!arg2) {
12566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12567     return ;
12568   }
12569   {
12570     try {
12571       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12579       };
12580     } catch (Dali::DaliException e) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12583       };
12584     } catch (...) {
12585       {
12586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12587       };
12588     }
12589   }
12590
12591 }
12592
12593
12594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12595   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12596   Dali::Vector3 *arg2 = 0 ;
12597
12598   arg1 = (Dali::Matrix *)jarg1;
12599   arg2 = (Dali::Vector3 *)jarg2;
12600   if (!arg2) {
12601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12602     return ;
12603   }
12604   {
12605     try {
12606       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12622       };
12623     }
12624   }
12625
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12630   void * jresult ;
12631   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12632   Dali::Vector4 *result = 0 ;
12633
12634   arg1 = (Dali::Matrix *)jarg1;
12635   {
12636     try {
12637       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (Dali::DaliException e) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656
12657   jresult = (void *)result;
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12663   void * jresult ;
12664   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12665   Dali::Vector3 *result = 0 ;
12666
12667   arg1 = (Dali::Matrix *)jarg1;
12668   {
12669     try {
12670       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12671     } catch (std::out_of_range& e) {
12672       {
12673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12674       };
12675     } catch (std::exception& e) {
12676       {
12677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12678       };
12679     } catch (Dali::DaliException e) {
12680       {
12681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12682       };
12683     } catch (...) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12686       };
12687     }
12688   }
12689
12690   jresult = (void *)result;
12691   return jresult;
12692 }
12693
12694
12695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12696   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12697   Dali::Vector4 *arg2 = 0 ;
12698
12699   arg1 = (Dali::Matrix *)jarg1;
12700   arg2 = (Dali::Vector4 *)jarg2;
12701   if (!arg2) {
12702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12703     return ;
12704   }
12705   {
12706     try {
12707       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12708     } catch (std::out_of_range& e) {
12709       {
12710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12711       };
12712     } catch (std::exception& e) {
12713       {
12714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (Dali::DaliException e) {
12717       {
12718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12719       };
12720     } catch (...) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12723       };
12724     }
12725   }
12726
12727 }
12728
12729
12730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12731   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12732   Dali::Vector3 *arg2 = 0 ;
12733
12734   arg1 = (Dali::Matrix *)jarg1;
12735   arg2 = (Dali::Vector3 *)jarg2;
12736   if (!arg2) {
12737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12738     return ;
12739   }
12740   {
12741     try {
12742       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12743     } catch (std::out_of_range& e) {
12744       {
12745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12746       };
12747     } catch (std::exception& e) {
12748       {
12749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (Dali::DaliException e) {
12752       {
12753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12754       };
12755     } catch (...) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12758       };
12759     }
12760   }
12761
12762 }
12763
12764
12765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12766   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12767
12768   arg1 = (Dali::Matrix *)jarg1;
12769   {
12770     try {
12771       (arg1)->OrthoNormalize();
12772     } catch (std::out_of_range& e) {
12773       {
12774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12775       };
12776     } catch (std::exception& e) {
12777       {
12778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12779       };
12780     } catch (Dali::DaliException e) {
12781       {
12782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12783       };
12784     } catch (...) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12787       };
12788     }
12789   }
12790
12791 }
12792
12793
12794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12795   void * jresult ;
12796   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12797   float *result = 0 ;
12798
12799   arg1 = (Dali::Matrix *)jarg1;
12800   {
12801     try {
12802       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12803     } catch (std::out_of_range& e) {
12804       {
12805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12806       };
12807     } catch (std::exception& e) {
12808       {
12809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (Dali::DaliException e) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12814       };
12815     } catch (...) {
12816       {
12817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12818       };
12819     }
12820   }
12821
12822   jresult = (void *)result;
12823   return jresult;
12824 }
12825
12826
12827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12828   Dali::Matrix *arg1 = 0 ;
12829   Dali::Matrix *arg2 = 0 ;
12830   Dali::Matrix *arg3 = 0 ;
12831
12832   arg1 = (Dali::Matrix *)jarg1;
12833   if (!arg1) {
12834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12835     return ;
12836   }
12837   arg2 = (Dali::Matrix *)jarg2;
12838   if (!arg2) {
12839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12840     return ;
12841   }
12842   arg3 = (Dali::Matrix *)jarg3;
12843   if (!arg3) {
12844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12845     return ;
12846   }
12847   {
12848     try {
12849       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12850     } catch (std::out_of_range& e) {
12851       {
12852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (std::exception& e) {
12855       {
12856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12857       };
12858     } catch (Dali::DaliException e) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12865       };
12866     }
12867   }
12868
12869 }
12870
12871
12872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12873   Dali::Matrix *arg1 = 0 ;
12874   Dali::Matrix *arg2 = 0 ;
12875   Dali::Quaternion *arg3 = 0 ;
12876
12877   arg1 = (Dali::Matrix *)jarg1;
12878   if (!arg1) {
12879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12880     return ;
12881   }
12882   arg2 = (Dali::Matrix *)jarg2;
12883   if (!arg2) {
12884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12885     return ;
12886   }
12887   arg3 = (Dali::Quaternion *)jarg3;
12888   if (!arg3) {
12889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12890     return ;
12891   }
12892   {
12893     try {
12894       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12895     } catch (std::out_of_range& e) {
12896       {
12897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12898       };
12899     } catch (std::exception& e) {
12900       {
12901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12902       };
12903     } catch (Dali::DaliException e) {
12904       {
12905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12906       };
12907     } catch (...) {
12908       {
12909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12910       };
12911     }
12912   }
12913
12914 }
12915
12916
12917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
12918   void * jresult ;
12919   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12920   Dali::Vector4 *arg2 = 0 ;
12921   Dali::Vector4 result;
12922
12923   arg1 = (Dali::Matrix *)jarg1;
12924   arg2 = (Dali::Vector4 *)jarg2;
12925   if (!arg2) {
12926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12927     return 0;
12928   }
12929   {
12930     try {
12931       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
12932     } catch (std::out_of_range& e) {
12933       {
12934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12935       };
12936     } catch (std::exception& e) {
12937       {
12938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (Dali::DaliException e) {
12941       {
12942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12943       };
12944     } catch (...) {
12945       {
12946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12947       };
12948     }
12949   }
12950
12951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12952   return jresult;
12953 }
12954
12955
12956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
12957   unsigned int jresult ;
12958   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12959   Dali::Matrix *arg2 = 0 ;
12960   bool result;
12961
12962   arg1 = (Dali::Matrix *)jarg1;
12963   arg2 = (Dali::Matrix *)jarg2;
12964   if (!arg2) {
12965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12966     return 0;
12967   }
12968   {
12969     try {
12970       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
12971     } catch (std::out_of_range& e) {
12972       {
12973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12974       };
12975     } catch (std::exception& e) {
12976       {
12977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12978       };
12979     } catch (Dali::DaliException e) {
12980       {
12981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12982       };
12983     } catch (...) {
12984       {
12985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12986       };
12987     }
12988   }
12989
12990   jresult = result;
12991   return jresult;
12992 }
12993
12994
12995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
12996   unsigned int jresult ;
12997   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12998   Dali::Matrix *arg2 = 0 ;
12999   bool result;
13000
13001   arg1 = (Dali::Matrix *)jarg1;
13002   arg2 = (Dali::Matrix *)jarg2;
13003   if (!arg2) {
13004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13005     return 0;
13006   }
13007   {
13008     try {
13009       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13010     } catch (std::out_of_range& e) {
13011       {
13012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13013       };
13014     } catch (std::exception& e) {
13015       {
13016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13017       };
13018     } catch (Dali::DaliException e) {
13019       {
13020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13021       };
13022     } catch (...) {
13023       {
13024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13025       };
13026     }
13027   }
13028
13029   jresult = result;
13030   return jresult;
13031 }
13032
13033
13034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13035   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13036   Dali::Vector3 *arg2 = 0 ;
13037   Dali::Quaternion *arg3 = 0 ;
13038   Dali::Vector3 *arg4 = 0 ;
13039
13040   arg1 = (Dali::Matrix *)jarg1;
13041   arg2 = (Dali::Vector3 *)jarg2;
13042   if (!arg2) {
13043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13044     return ;
13045   }
13046   arg3 = (Dali::Quaternion *)jarg3;
13047   if (!arg3) {
13048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13049     return ;
13050   }
13051   arg4 = (Dali::Vector3 *)jarg4;
13052   if (!arg4) {
13053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13054     return ;
13055   }
13056   {
13057     try {
13058       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13059     } catch (std::out_of_range& e) {
13060       {
13061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13062       };
13063     } catch (std::exception& e) {
13064       {
13065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13066       };
13067     } catch (Dali::DaliException e) {
13068       {
13069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13070       };
13071     } catch (...) {
13072       {
13073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13074       };
13075     }
13076   }
13077
13078 }
13079
13080
13081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13082   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13083   Dali::Vector3 *arg2 = 0 ;
13084   Dali::Quaternion *arg3 = 0 ;
13085   Dali::Vector3 *arg4 = 0 ;
13086
13087   arg1 = (Dali::Matrix *)jarg1;
13088   arg2 = (Dali::Vector3 *)jarg2;
13089   if (!arg2) {
13090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13091     return ;
13092   }
13093   arg3 = (Dali::Quaternion *)jarg3;
13094   if (!arg3) {
13095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13096     return ;
13097   }
13098   arg4 = (Dali::Vector3 *)jarg4;
13099   if (!arg4) {
13100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13101     return ;
13102   }
13103   {
13104     try {
13105       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13106     } catch (std::out_of_range& e) {
13107       {
13108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13109       };
13110     } catch (std::exception& e) {
13111       {
13112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13113       };
13114     } catch (Dali::DaliException e) {
13115       {
13116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13117       };
13118     } catch (...) {
13119       {
13120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13121       };
13122     }
13123   }
13124
13125 }
13126
13127
13128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13129   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13130   Dali::Vector3 *arg2 = 0 ;
13131   Dali::Vector3 *arg3 = 0 ;
13132   Dali::Vector3 *arg4 = 0 ;
13133   Dali::Vector3 *arg5 = 0 ;
13134
13135   arg1 = (Dali::Matrix *)jarg1;
13136   arg2 = (Dali::Vector3 *)jarg2;
13137   if (!arg2) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13139     return ;
13140   }
13141   arg3 = (Dali::Vector3 *)jarg3;
13142   if (!arg3) {
13143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13144     return ;
13145   }
13146   arg4 = (Dali::Vector3 *)jarg4;
13147   if (!arg4) {
13148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13149     return ;
13150   }
13151   arg5 = (Dali::Vector3 *)jarg5;
13152   if (!arg5) {
13153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13154     return ;
13155   }
13156   {
13157     try {
13158       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13159     } catch (std::out_of_range& e) {
13160       {
13161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13162       };
13163     } catch (std::exception& e) {
13164       {
13165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13166       };
13167     } catch (Dali::DaliException e) {
13168       {
13169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13170       };
13171     } catch (...) {
13172       {
13173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13174       };
13175     }
13176   }
13177
13178 }
13179
13180
13181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13182   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13183   Dali::Vector3 *arg2 = 0 ;
13184   Dali::Quaternion *arg3 = 0 ;
13185   Dali::Vector3 *arg4 = 0 ;
13186
13187   arg1 = (Dali::Matrix *)jarg1;
13188   arg2 = (Dali::Vector3 *)jarg2;
13189   if (!arg2) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13191     return ;
13192   }
13193   arg3 = (Dali::Quaternion *)jarg3;
13194   if (!arg3) {
13195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13196     return ;
13197   }
13198   arg4 = (Dali::Vector3 *)jarg4;
13199   if (!arg4) {
13200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13201     return ;
13202   }
13203   {
13204     try {
13205       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13206     } catch (std::out_of_range& e) {
13207       {
13208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13209       };
13210     } catch (std::exception& e) {
13211       {
13212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13213       };
13214     } catch (Dali::DaliException e) {
13215       {
13216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13217       };
13218     } catch (...) {
13219       {
13220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13221       };
13222     }
13223   }
13224
13225 }
13226
13227
13228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13229   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13230
13231   arg1 = (Dali::Matrix *)jarg1;
13232   {
13233     try {
13234       delete arg1;
13235     } catch (std::out_of_range& e) {
13236       {
13237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13238       };
13239     } catch (std::exception& e) {
13240       {
13241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13242       };
13243     } catch (Dali::DaliException e) {
13244       {
13245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13246       };
13247     } catch (...) {
13248       {
13249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13250       };
13251     }
13252   }
13253
13254 }
13255
13256
13257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13258   void * jresult ;
13259   Dali::Matrix3 *result = 0 ;
13260
13261   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13262   jresult = (void *)result;
13263   return jresult;
13264 }
13265
13266
13267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13268   void * jresult ;
13269   Dali::Matrix3 *result = 0 ;
13270
13271   {
13272     try {
13273       result = (Dali::Matrix3 *)new Dali::Matrix3();
13274     } catch (std::out_of_range& e) {
13275       {
13276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13277       };
13278     } catch (std::exception& e) {
13279       {
13280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13281       };
13282     } catch (Dali::DaliException e) {
13283       {
13284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13285       };
13286     } catch (...) {
13287       {
13288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13289       };
13290     }
13291   }
13292
13293   jresult = (void *)result;
13294   return jresult;
13295 }
13296
13297
13298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13299   void * jresult ;
13300   Dali::Matrix3 *arg1 = 0 ;
13301   Dali::Matrix3 *result = 0 ;
13302
13303   arg1 = (Dali::Matrix3 *)jarg1;
13304   if (!arg1) {
13305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13306     return 0;
13307   }
13308   {
13309     try {
13310       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13311     } catch (std::out_of_range& e) {
13312       {
13313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13314       };
13315     } catch (std::exception& e) {
13316       {
13317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13318       };
13319     } catch (Dali::DaliException e) {
13320       {
13321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13322       };
13323     } catch (...) {
13324       {
13325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13326       };
13327     }
13328   }
13329
13330   jresult = (void *)result;
13331   return jresult;
13332 }
13333
13334
13335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13336   void * jresult ;
13337   Dali::Matrix *arg1 = 0 ;
13338   Dali::Matrix3 *result = 0 ;
13339
13340   arg1 = (Dali::Matrix *)jarg1;
13341   if (!arg1) {
13342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13343     return 0;
13344   }
13345   {
13346     try {
13347       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13348     } catch (std::out_of_range& e) {
13349       {
13350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13351       };
13352     } catch (std::exception& e) {
13353       {
13354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13355       };
13356     } catch (Dali::DaliException e) {
13357       {
13358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13359       };
13360     } catch (...) {
13361       {
13362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13363       };
13364     }
13365   }
13366
13367   jresult = (void *)result;
13368   return jresult;
13369 }
13370
13371
13372 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) {
13373   void * jresult ;
13374   float arg1 ;
13375   float arg2 ;
13376   float arg3 ;
13377   float arg4 ;
13378   float arg5 ;
13379   float arg6 ;
13380   float arg7 ;
13381   float arg8 ;
13382   float arg9 ;
13383   Dali::Matrix3 *result = 0 ;
13384
13385   arg1 = (float)jarg1;
13386   arg2 = (float)jarg2;
13387   arg3 = (float)jarg3;
13388   arg4 = (float)jarg4;
13389   arg5 = (float)jarg5;
13390   arg6 = (float)jarg6;
13391   arg7 = (float)jarg7;
13392   arg8 = (float)jarg8;
13393   arg9 = (float)jarg9;
13394   {
13395     try {
13396       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13397     } catch (std::out_of_range& e) {
13398       {
13399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13400       };
13401     } catch (std::exception& e) {
13402       {
13403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13404       };
13405     } catch (Dali::DaliException e) {
13406       {
13407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13408       };
13409     } catch (...) {
13410       {
13411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13412       };
13413     }
13414   }
13415
13416   jresult = (void *)result;
13417   return jresult;
13418 }
13419
13420
13421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13422   void * jresult ;
13423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13424   Dali::Matrix3 *arg2 = 0 ;
13425   Dali::Matrix3 *result = 0 ;
13426
13427   arg1 = (Dali::Matrix3 *)jarg1;
13428   arg2 = (Dali::Matrix3 *)jarg2;
13429   if (!arg2) {
13430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13431     return 0;
13432   }
13433   {
13434     try {
13435       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13436     } catch (std::out_of_range& e) {
13437       {
13438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13439       };
13440     } catch (std::exception& e) {
13441       {
13442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13443       };
13444     } catch (Dali::DaliException e) {
13445       {
13446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13447       };
13448     } catch (...) {
13449       {
13450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13451       };
13452     }
13453   }
13454
13455   jresult = (void *)result;
13456   return jresult;
13457 }
13458
13459
13460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13461   void * jresult ;
13462   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13463   Dali::Matrix *arg2 = 0 ;
13464   Dali::Matrix3 *result = 0 ;
13465
13466   arg1 = (Dali::Matrix3 *)jarg1;
13467   arg2 = (Dali::Matrix *)jarg2;
13468   if (!arg2) {
13469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13470     return 0;
13471   }
13472   {
13473     try {
13474       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13475     } catch (std::out_of_range& e) {
13476       {
13477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13478       };
13479     } catch (std::exception& e) {
13480       {
13481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13482       };
13483     } catch (Dali::DaliException e) {
13484       {
13485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13486       };
13487     } catch (...) {
13488       {
13489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13490       };
13491     }
13492   }
13493
13494   jresult = (void *)result;
13495   return jresult;
13496 }
13497
13498
13499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13500   unsigned int jresult ;
13501   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13502   Dali::Matrix3 *arg2 = 0 ;
13503   bool result;
13504
13505   arg1 = (Dali::Matrix3 *)jarg1;
13506   arg2 = (Dali::Matrix3 *)jarg2;
13507   if (!arg2) {
13508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13509     return 0;
13510   }
13511   {
13512     try {
13513       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13514     } catch (std::out_of_range& e) {
13515       {
13516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13517       };
13518     } catch (std::exception& e) {
13519       {
13520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13521       };
13522     } catch (Dali::DaliException e) {
13523       {
13524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13525       };
13526     } catch (...) {
13527       {
13528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13529       };
13530     }
13531   }
13532
13533   jresult = result;
13534   return jresult;
13535 }
13536
13537
13538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13539   unsigned int jresult ;
13540   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13541   Dali::Matrix3 *arg2 = 0 ;
13542   bool result;
13543
13544   arg1 = (Dali::Matrix3 *)jarg1;
13545   arg2 = (Dali::Matrix3 *)jarg2;
13546   if (!arg2) {
13547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13548     return 0;
13549   }
13550   {
13551     try {
13552       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13553     } catch (std::out_of_range& e) {
13554       {
13555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13556       };
13557     } catch (std::exception& e) {
13558       {
13559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13560       };
13561     } catch (Dali::DaliException e) {
13562       {
13563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13564       };
13565     } catch (...) {
13566       {
13567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13568       };
13569     }
13570   }
13571
13572   jresult = result;
13573   return jresult;
13574 }
13575
13576
13577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13578   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13579
13580   arg1 = (Dali::Matrix3 *)jarg1;
13581   {
13582     try {
13583       delete arg1;
13584     } catch (std::out_of_range& e) {
13585       {
13586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13587       };
13588     } catch (std::exception& e) {
13589       {
13590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13591       };
13592     } catch (Dali::DaliException e) {
13593       {
13594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13595       };
13596     } catch (...) {
13597       {
13598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13599       };
13600     }
13601   }
13602
13603 }
13604
13605
13606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13607   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13608
13609   arg1 = (Dali::Matrix3 *)jarg1;
13610   {
13611     try {
13612       (arg1)->SetIdentity();
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13620       };
13621     } catch (Dali::DaliException e) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13624       };
13625     } catch (...) {
13626       {
13627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13628       };
13629     }
13630   }
13631
13632 }
13633
13634
13635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13636   void * jresult ;
13637   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13638   float *result = 0 ;
13639
13640   arg1 = (Dali::Matrix3 *)jarg1;
13641   {
13642     try {
13643       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (Dali::DaliException e) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13655       };
13656     } catch (...) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13659       };
13660     }
13661   }
13662
13663   jresult = (void *)result;
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13669   unsigned int jresult ;
13670   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13671   bool result;
13672
13673   arg1 = (Dali::Matrix3 *)jarg1;
13674   {
13675     try {
13676       result = (bool)(arg1)->Invert();
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13684       };
13685     } catch (Dali::DaliException e) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13692       };
13693     }
13694   }
13695
13696   jresult = result;
13697   return jresult;
13698 }
13699
13700
13701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13702   unsigned int jresult ;
13703   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13704   bool result;
13705
13706   arg1 = (Dali::Matrix3 *)jarg1;
13707   {
13708     try {
13709       result = (bool)(arg1)->Transpose();
13710     } catch (std::out_of_range& e) {
13711       {
13712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13713       };
13714     } catch (std::exception& e) {
13715       {
13716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13717       };
13718     } catch (Dali::DaliException e) {
13719       {
13720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13721       };
13722     } catch (...) {
13723       {
13724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13725       };
13726     }
13727   }
13728
13729   jresult = result;
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13735   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13736   float arg2 ;
13737
13738   arg1 = (Dali::Matrix3 *)jarg1;
13739   arg2 = (float)jarg2;
13740   {
13741     try {
13742       (arg1)->Scale(arg2);
13743     } catch (std::out_of_range& e) {
13744       {
13745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13746       };
13747     } catch (std::exception& e) {
13748       {
13749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13750       };
13751     } catch (Dali::DaliException e) {
13752       {
13753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13754       };
13755     } catch (...) {
13756       {
13757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13758       };
13759     }
13760   }
13761
13762 }
13763
13764
13765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13766   float jresult ;
13767   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13768   float result;
13769
13770   arg1 = (Dali::Matrix3 *)jarg1;
13771   {
13772     try {
13773       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13774     } catch (std::out_of_range& e) {
13775       {
13776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13777       };
13778     } catch (std::exception& e) {
13779       {
13780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13781       };
13782     } catch (Dali::DaliException e) {
13783       {
13784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13785       };
13786     } catch (...) {
13787       {
13788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13789       };
13790     }
13791   }
13792
13793   jresult = result;
13794   return jresult;
13795 }
13796
13797
13798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13799   unsigned int jresult ;
13800   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13801   bool result;
13802
13803   arg1 = (Dali::Matrix3 *)jarg1;
13804   {
13805     try {
13806       result = (bool)(arg1)->ScaledInverseTranspose();
13807     } catch (std::out_of_range& e) {
13808       {
13809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13810       };
13811     } catch (std::exception& e) {
13812       {
13813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13814       };
13815     } catch (Dali::DaliException e) {
13816       {
13817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13818       };
13819     } catch (...) {
13820       {
13821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13822       };
13823     }
13824   }
13825
13826   jresult = result;
13827   return jresult;
13828 }
13829
13830
13831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13832   Dali::Matrix3 *arg1 = 0 ;
13833   Dali::Matrix3 *arg2 = 0 ;
13834   Dali::Matrix3 *arg3 = 0 ;
13835
13836   arg1 = (Dali::Matrix3 *)jarg1;
13837   if (!arg1) {
13838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13839     return ;
13840   }
13841   arg2 = (Dali::Matrix3 *)jarg2;
13842   if (!arg2) {
13843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13844     return ;
13845   }
13846   arg3 = (Dali::Matrix3 *)jarg3;
13847   if (!arg3) {
13848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13849     return ;
13850   }
13851   {
13852     try {
13853       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13854     } catch (std::out_of_range& e) {
13855       {
13856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13857       };
13858     } catch (std::exception& e) {
13859       {
13860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13861       };
13862     } catch (Dali::DaliException e) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13865       };
13866     } catch (...) {
13867       {
13868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13869       };
13870     }
13871   }
13872
13873 }
13874
13875
13876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13877   float jresult ;
13878   float arg1 ;
13879   float arg2 ;
13880   float result;
13881
13882   arg1 = (float)jarg1;
13883   arg2 = (float)jarg2;
13884   {
13885     try {
13886       result = (float)Dali::Random::Range(arg1,arg2);
13887     } catch (std::out_of_range& e) {
13888       {
13889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13890       };
13891     } catch (std::exception& e) {
13892       {
13893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13894       };
13895     } catch (Dali::DaliException e) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13898       };
13899     } catch (...) {
13900       {
13901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13902       };
13903     }
13904   }
13905
13906   jresult = result;
13907   return jresult;
13908 }
13909
13910
13911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
13912   void * jresult ;
13913   Dali::Vector4 result;
13914
13915   {
13916     try {
13917       result = Dali::Random::Axis();
13918     } catch (std::out_of_range& e) {
13919       {
13920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (std::exception& e) {
13923       {
13924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (Dali::DaliException e) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13929       };
13930     } catch (...) {
13931       {
13932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13933       };
13934     }
13935   }
13936
13937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13938   return jresult;
13939 }
13940
13941
13942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
13943   void * jresult ;
13944   Dali::AngleAxis *result = 0 ;
13945
13946   {
13947     try {
13948       result = (Dali::AngleAxis *)new Dali::AngleAxis();
13949     } catch (std::out_of_range& e) {
13950       {
13951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13952       };
13953     } catch (std::exception& e) {
13954       {
13955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13956       };
13957     } catch (Dali::DaliException e) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13960       };
13961     } catch (...) {
13962       {
13963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13964       };
13965     }
13966   }
13967
13968   jresult = (void *)result;
13969   return jresult;
13970 }
13971
13972
13973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
13974   void * jresult ;
13975   Dali::Radian arg1 ;
13976   Dali::Vector3 *arg2 = 0 ;
13977   Dali::Radian *argp1 ;
13978   Dali::AngleAxis *result = 0 ;
13979
13980   argp1 = (Dali::Radian *)jarg1;
13981   if (!argp1) {
13982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
13983     return 0;
13984   }
13985   arg1 = *argp1;
13986   arg2 = (Dali::Vector3 *)jarg2;
13987   if (!arg2) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13989     return 0;
13990   }
13991   {
13992     try {
13993       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14009       };
14010     }
14011   }
14012
14013   jresult = (void *)result;
14014   return jresult;
14015 }
14016
14017
14018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14019   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14020   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14021
14022   arg1 = (Dali::AngleAxis *)jarg1;
14023   arg2 = (Dali::Radian *)jarg2;
14024   if (arg1) (arg1)->angle = *arg2;
14025 }
14026
14027
14028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14029   void * jresult ;
14030   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14031   Dali::Radian *result = 0 ;
14032
14033   arg1 = (Dali::AngleAxis *)jarg1;
14034   result = (Dali::Radian *)& ((arg1)->angle);
14035   jresult = (void *)result;
14036   return jresult;
14037 }
14038
14039
14040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14041   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14042   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14043
14044   arg1 = (Dali::AngleAxis *)jarg1;
14045   arg2 = (Dali::Vector3 *)jarg2;
14046   if (arg1) (arg1)->axis = *arg2;
14047 }
14048
14049
14050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14051   void * jresult ;
14052   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14053   Dali::Vector3 *result = 0 ;
14054
14055   arg1 = (Dali::AngleAxis *)jarg1;
14056   result = (Dali::Vector3 *)& ((arg1)->axis);
14057   jresult = (void *)result;
14058   return jresult;
14059 }
14060
14061
14062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14063   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14064
14065   arg1 = (Dali::AngleAxis *)jarg1;
14066   {
14067     try {
14068       delete arg1;
14069     } catch (std::out_of_range& e) {
14070       {
14071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14072       };
14073     } catch (std::exception& e) {
14074       {
14075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14076       };
14077     } catch (Dali::DaliException e) {
14078       {
14079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14080       };
14081     } catch (...) {
14082       {
14083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14084       };
14085     }
14086   }
14087
14088 }
14089
14090
14091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14092   unsigned int jresult ;
14093   Dali::AngleAxis *arg1 = 0 ;
14094   Dali::AngleAxis *arg2 = 0 ;
14095   bool result;
14096
14097   arg1 = (Dali::AngleAxis *)jarg1;
14098   if (!arg1) {
14099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14100     return 0;
14101   }
14102   arg2 = (Dali::AngleAxis *)jarg2;
14103   if (!arg2) {
14104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14105     return 0;
14106   }
14107   {
14108     try {
14109       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis 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 = result;
14130   return jresult;
14131 }
14132
14133
14134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14135   unsigned int jresult ;
14136   unsigned int arg1 ;
14137   unsigned int result;
14138
14139   arg1 = (unsigned int)jarg1;
14140   {
14141     try {
14142       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14143     } catch (std::out_of_range& e) {
14144       {
14145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14146       };
14147     } catch (std::exception& e) {
14148       {
14149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14150       };
14151     } catch (Dali::DaliException e) {
14152       {
14153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14154       };
14155     } catch (...) {
14156       {
14157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14158       };
14159     }
14160   }
14161
14162   jresult = result;
14163   return jresult;
14164 }
14165
14166
14167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14168   unsigned int jresult ;
14169   unsigned int arg1 ;
14170   bool result;
14171
14172   arg1 = (unsigned int)jarg1;
14173   {
14174     try {
14175       result = (bool)Dali::IsPowerOfTwo(arg1);
14176     } catch (std::out_of_range& e) {
14177       {
14178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14179       };
14180     } catch (std::exception& e) {
14181       {
14182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14183       };
14184     } catch (Dali::DaliException e) {
14185       {
14186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14187       };
14188     } catch (...) {
14189       {
14190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14191       };
14192     }
14193   }
14194
14195   jresult = result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14201   float jresult ;
14202   float arg1 ;
14203   float arg2 ;
14204   float result;
14205
14206   arg1 = (float)jarg1;
14207   arg2 = (float)jarg2;
14208   {
14209     try {
14210       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14211     } catch (std::out_of_range& e) {
14212       {
14213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14214       };
14215     } catch (std::exception& e) {
14216       {
14217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14218       };
14219     } catch (Dali::DaliException e) {
14220       {
14221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14222       };
14223     } catch (...) {
14224       {
14225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14226       };
14227     }
14228   }
14229
14230   jresult = result;
14231   return jresult;
14232 }
14233
14234
14235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14236   unsigned int jresult ;
14237   float arg1 ;
14238   bool result;
14239
14240   arg1 = (float)jarg1;
14241   {
14242     try {
14243       result = (bool)Dali::EqualsZero(arg1);
14244     } catch (std::out_of_range& e) {
14245       {
14246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14247       };
14248     } catch (std::exception& e) {
14249       {
14250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (Dali::DaliException e) {
14253       {
14254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14259       };
14260     }
14261   }
14262
14263   jresult = result;
14264   return jresult;
14265 }
14266
14267
14268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14269   unsigned int jresult ;
14270   float arg1 ;
14271   float arg2 ;
14272   bool result;
14273
14274   arg1 = (float)jarg1;
14275   arg2 = (float)jarg2;
14276   {
14277     try {
14278       result = (bool)Dali::Equals(arg1,arg2);
14279     } catch (std::out_of_range& e) {
14280       {
14281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (std::exception& e) {
14284       {
14285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (Dali::DaliException e) {
14288       {
14289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14290       };
14291     } catch (...) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14294       };
14295     }
14296   }
14297
14298   jresult = result;
14299   return jresult;
14300 }
14301
14302
14303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14304   unsigned int jresult ;
14305   float arg1 ;
14306   float arg2 ;
14307   float arg3 ;
14308   bool result;
14309
14310   arg1 = (float)jarg1;
14311   arg2 = (float)jarg2;
14312   arg3 = (float)jarg3;
14313   {
14314     try {
14315       result = (bool)Dali::Equals(arg1,arg2,arg3);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   int arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (int)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::Round(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14376   float jresult ;
14377   float arg1 ;
14378   float arg2 ;
14379   float arg3 ;
14380   float result;
14381
14382   arg1 = (float)jarg1;
14383   arg2 = (float)jarg2;
14384   arg3 = (float)jarg3;
14385   {
14386     try {
14387       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14388     } catch (std::out_of_range& e) {
14389       {
14390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (std::exception& e) {
14393       {
14394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14395       };
14396     } catch (Dali::DaliException e) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14399       };
14400     } catch (...) {
14401       {
14402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14403       };
14404     }
14405   }
14406
14407   jresult = result;
14408   return jresult;
14409 }
14410
14411
14412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14413   float jresult ;
14414   float arg1 ;
14415   float arg2 ;
14416   float arg3 ;
14417   float arg4 ;
14418   float result;
14419
14420   arg1 = (float)jarg1;
14421   arg2 = (float)jarg2;
14422   arg3 = (float)jarg3;
14423   arg4 = (float)jarg4;
14424   {
14425     try {
14426       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14427     } catch (std::out_of_range& e) {
14428       {
14429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14430       };
14431     } catch (std::exception& e) {
14432       {
14433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14434       };
14435     } catch (Dali::DaliException e) {
14436       {
14437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14438       };
14439     } catch (...) {
14440       {
14441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14442       };
14443     }
14444   }
14445
14446   jresult = result;
14447   return jresult;
14448 }
14449
14450
14451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14452   int jresult ;
14453   int result;
14454
14455   result = (int)(int)Dali::Property::INVALID_INDEX;
14456   jresult = result;
14457   return jresult;
14458 }
14459
14460
14461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14462   int jresult ;
14463   int result;
14464
14465   result = (int)(int)Dali::Property::INVALID_KEY;
14466   jresult = result;
14467   return jresult;
14468 }
14469
14470
14471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14472   int jresult ;
14473   int result;
14474
14475   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14476   jresult = result;
14477   return jresult;
14478 }
14479
14480
14481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14482   void * jresult ;
14483   Dali::Handle *arg1 = 0 ;
14484   Dali::Property::Index arg2 ;
14485   Dali::Property *result = 0 ;
14486
14487   arg1 = (Dali::Handle *)jarg1;
14488   if (!arg1) {
14489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14490     return 0;
14491   }
14492   arg2 = (Dali::Property::Index)jarg2;
14493   {
14494     try {
14495       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14496     } catch (std::out_of_range& e) {
14497       {
14498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14499       };
14500     } catch (std::exception& e) {
14501       {
14502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14503       };
14504     } catch (Dali::DaliException e) {
14505       {
14506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14507       };
14508     } catch (...) {
14509       {
14510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14511       };
14512     }
14513   }
14514
14515   jresult = (void *)result;
14516   return jresult;
14517 }
14518
14519
14520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14521   void * jresult ;
14522   Dali::Handle *arg1 = 0 ;
14523   Dali::Property::Index arg2 ;
14524   int arg3 ;
14525   Dali::Property *result = 0 ;
14526
14527   arg1 = (Dali::Handle *)jarg1;
14528   if (!arg1) {
14529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14530     return 0;
14531   }
14532   arg2 = (Dali::Property::Index)jarg2;
14533   arg3 = (int)jarg3;
14534   {
14535     try {
14536       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14537     } catch (std::out_of_range& e) {
14538       {
14539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14540       };
14541     } catch (std::exception& e) {
14542       {
14543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14544       };
14545     } catch (Dali::DaliException e) {
14546       {
14547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14548       };
14549     } catch (...) {
14550       {
14551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14552       };
14553     }
14554   }
14555
14556   jresult = (void *)result;
14557   return jresult;
14558 }
14559
14560
14561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14562   void * jresult ;
14563   Dali::Handle *arg1 = 0 ;
14564   std::string *arg2 = 0 ;
14565   Dali::Property *result = 0 ;
14566
14567   arg1 = (Dali::Handle *)jarg1;
14568   if (!arg1) {
14569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14570     return 0;
14571   }
14572   if (!jarg2) {
14573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14574     return 0;
14575   }
14576   std::string arg2_str(jarg2);
14577   arg2 = &arg2_str;
14578   {
14579     try {
14580       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14581     } catch (std::out_of_range& e) {
14582       {
14583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14584       };
14585     } catch (std::exception& e) {
14586       {
14587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14588       };
14589     } catch (Dali::DaliException e) {
14590       {
14591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14592       };
14593     } catch (...) {
14594       {
14595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14596       };
14597     }
14598   }
14599
14600   jresult = (void *)result;
14601
14602   //argout typemap for const std::string&
14603
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14609   void * jresult ;
14610   Dali::Handle *arg1 = 0 ;
14611   std::string *arg2 = 0 ;
14612   int arg3 ;
14613   Dali::Property *result = 0 ;
14614
14615   arg1 = (Dali::Handle *)jarg1;
14616   if (!arg1) {
14617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14618     return 0;
14619   }
14620   if (!jarg2) {
14621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14622     return 0;
14623   }
14624   std::string arg2_str(jarg2);
14625   arg2 = &arg2_str;
14626   arg3 = (int)jarg3;
14627   {
14628     try {
14629       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (Dali::DaliException e) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14645       };
14646     }
14647   }
14648
14649   jresult = (void *)result;
14650
14651   //argout typemap for const std::string&
14652
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14658   Dali::Property *arg1 = (Dali::Property *) 0 ;
14659
14660   arg1 = (Dali::Property *)jarg1;
14661   {
14662     try {
14663       delete arg1;
14664     } catch (std::out_of_range& e) {
14665       {
14666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14667       };
14668     } catch (std::exception& e) {
14669       {
14670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14671       };
14672     } catch (Dali::DaliException e) {
14673       {
14674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14675       };
14676     } catch (...) {
14677       {
14678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14679       };
14680     }
14681   }
14682
14683 }
14684
14685
14686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14687   Dali::Property *arg1 = (Dali::Property *) 0 ;
14688   Dali::Handle *arg2 = 0 ;
14689
14690   arg1 = (Dali::Property *)jarg1;
14691   arg2 = (Dali::Handle *)jarg2;
14692   if (!arg2) {
14693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14694     return ;
14695   }
14696   if (arg1) (arg1)->object = *arg2;
14697 }
14698
14699
14700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14701   void * jresult ;
14702   Dali::Property *arg1 = (Dali::Property *) 0 ;
14703   Dali::Handle *result = 0 ;
14704
14705   arg1 = (Dali::Property *)jarg1;
14706   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14707   jresult = (void *)result;
14708   return jresult;
14709 }
14710
14711
14712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14713   Dali::Property *arg1 = (Dali::Property *) 0 ;
14714   Dali::Property::Index arg2 ;
14715
14716   arg1 = (Dali::Property *)jarg1;
14717   arg2 = (Dali::Property::Index)jarg2;
14718   if (arg1) (arg1)->propertyIndex = arg2;
14719 }
14720
14721
14722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14723   int jresult ;
14724   Dali::Property *arg1 = (Dali::Property *) 0 ;
14725   Dali::Property::Index result;
14726
14727   arg1 = (Dali::Property *)jarg1;
14728   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14729   jresult = result;
14730   return jresult;
14731 }
14732
14733
14734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14735   Dali::Property *arg1 = (Dali::Property *) 0 ;
14736   int arg2 ;
14737
14738   arg1 = (Dali::Property *)jarg1;
14739   arg2 = (int)jarg2;
14740   if (arg1) (arg1)->componentIndex = arg2;
14741 }
14742
14743
14744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14745   int jresult ;
14746   Dali::Property *arg1 = (Dali::Property *) 0 ;
14747   int result;
14748
14749   arg1 = (Dali::Property *)jarg1;
14750   result = (int) ((arg1)->componentIndex);
14751   jresult = result;
14752   return jresult;
14753 }
14754
14755
14756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14757   void * jresult ;
14758   Dali::Property::Array *result = 0 ;
14759
14760   {
14761     try {
14762       result = (Dali::Property::Array *)new Dali::Property::Array();
14763     } catch (std::out_of_range& e) {
14764       {
14765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14766       };
14767     } catch (std::exception& e) {
14768       {
14769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (Dali::DaliException e) {
14772       {
14773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14774       };
14775     } catch (...) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14778       };
14779     }
14780   }
14781
14782   jresult = (void *)result;
14783   return jresult;
14784 }
14785
14786
14787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14788   void * jresult ;
14789   Dali::Property::Array *arg1 = 0 ;
14790   Dali::Property::Array *result = 0 ;
14791
14792   arg1 = (Dali::Property::Array *)jarg1;
14793   if (!arg1) {
14794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14795     return 0;
14796   }
14797   {
14798     try {
14799       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14800     } catch (std::out_of_range& e) {
14801       {
14802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14803       };
14804     } catch (std::exception& e) {
14805       {
14806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14807       };
14808     } catch (Dali::DaliException e) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14811       };
14812     } catch (...) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14815       };
14816     }
14817   }
14818
14819   jresult = (void *)result;
14820   return jresult;
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14825   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14826
14827   arg1 = (Dali::Property::Array *)jarg1;
14828   {
14829     try {
14830       delete arg1;
14831     } catch (std::out_of_range& e) {
14832       {
14833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14834       };
14835     } catch (std::exception& e) {
14836       {
14837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14838       };
14839     } catch (Dali::DaliException e) {
14840       {
14841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14842       };
14843     } catch (...) {
14844       {
14845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14846       };
14847     }
14848   }
14849
14850 }
14851
14852
14853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14854   unsigned long jresult ;
14855   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14856   Dali::Property::Array::SizeType result;
14857
14858   arg1 = (Dali::Property::Array *)jarg1;
14859   {
14860     try {
14861       result = ((Dali::Property::Array const *)arg1)->Size();
14862     } catch (std::out_of_range& e) {
14863       {
14864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14865       };
14866     } catch (std::exception& e) {
14867       {
14868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14869       };
14870     } catch (Dali::DaliException e) {
14871       {
14872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14873       };
14874     } catch (...) {
14875       {
14876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14877       };
14878     }
14879   }
14880
14881   jresult = (unsigned long)result;
14882   return jresult;
14883 }
14884
14885
14886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14887   unsigned long jresult ;
14888   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14889   Dali::Property::Array::SizeType result;
14890
14891   arg1 = (Dali::Property::Array *)jarg1;
14892   {
14893     try {
14894       result = ((Dali::Property::Array const *)arg1)->Count();
14895     } catch (std::out_of_range& e) {
14896       {
14897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14898       };
14899     } catch (std::exception& e) {
14900       {
14901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14902       };
14903     } catch (Dali::DaliException e) {
14904       {
14905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14906       };
14907     } catch (...) {
14908       {
14909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14910       };
14911     }
14912   }
14913
14914   jresult = (unsigned long)result;
14915   return jresult;
14916 }
14917
14918
14919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
14920   unsigned int jresult ;
14921   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14922   bool result;
14923
14924   arg1 = (Dali::Property::Array *)jarg1;
14925   {
14926     try {
14927       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
14928     } catch (std::out_of_range& e) {
14929       {
14930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14931       };
14932     } catch (std::exception& e) {
14933       {
14934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14935       };
14936     } catch (Dali::DaliException e) {
14937       {
14938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14939       };
14940     } catch (...) {
14941       {
14942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14943       };
14944     }
14945   }
14946
14947   jresult = result;
14948   return jresult;
14949 }
14950
14951
14952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
14953   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14954
14955   arg1 = (Dali::Property::Array *)jarg1;
14956   {
14957     try {
14958       (arg1)->Clear();
14959     } catch (std::out_of_range& e) {
14960       {
14961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14962       };
14963     } catch (std::exception& e) {
14964       {
14965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14966       };
14967     } catch (Dali::DaliException e) {
14968       {
14969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14970       };
14971     } catch (...) {
14972       {
14973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14974       };
14975     }
14976   }
14977
14978 }
14979
14980
14981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
14982   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14983   Dali::Property::Array::SizeType arg2 ;
14984
14985   arg1 = (Dali::Property::Array *)jarg1;
14986   arg2 = (Dali::Property::Array::SizeType)jarg2;
14987   {
14988     try {
14989       (arg1)->Reserve(arg2);
14990     } catch (std::out_of_range& e) {
14991       {
14992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14993       };
14994     } catch (std::exception& e) {
14995       {
14996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14997       };
14998     } catch (Dali::DaliException e) {
14999       {
15000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15001       };
15002     } catch (...) {
15003       {
15004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15005       };
15006     }
15007   }
15008
15009 }
15010
15011
15012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15013   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15014   Dali::Property::Array::SizeType arg2 ;
15015
15016   arg1 = (Dali::Property::Array *)jarg1;
15017   arg2 = (Dali::Property::Array::SizeType)jarg2;
15018   {
15019     try {
15020       (arg1)->Resize(arg2);
15021     } catch (std::out_of_range& e) {
15022       {
15023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15024       };
15025     } catch (std::exception& e) {
15026       {
15027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15028       };
15029     } catch (Dali::DaliException e) {
15030       {
15031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15032       };
15033     } catch (...) {
15034       {
15035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15036       };
15037     }
15038   }
15039
15040 }
15041
15042
15043 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15044   unsigned long jresult ;
15045   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15046   Dali::Property::Array::SizeType result;
15047
15048   arg1 = (Dali::Property::Array *)jarg1;
15049   {
15050     try {
15051       result = (arg1)->Capacity();
15052     } catch (std::out_of_range& e) {
15053       {
15054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15055       };
15056     } catch (std::exception& e) {
15057       {
15058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15059       };
15060     } catch (Dali::DaliException e) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15063       };
15064     } catch (...) {
15065       {
15066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15067       };
15068     }
15069   }
15070
15071   jresult = (unsigned long)result;
15072   return jresult;
15073 }
15074
15075
15076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15077   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15078   Dali::Property::Value *arg2 = 0 ;
15079
15080   arg1 = (Dali::Property::Array *)jarg1;
15081   arg2 = (Dali::Property::Value *)jarg2;
15082   if (!arg2) {
15083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15084     return ;
15085   }
15086   {
15087     try {
15088       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15089     } catch (std::out_of_range& e) {
15090       {
15091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15092       };
15093     } catch (std::exception& e) {
15094       {
15095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15096       };
15097     } catch (Dali::DaliException e) {
15098       {
15099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15100       };
15101     } catch (...) {
15102       {
15103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15104       };
15105     }
15106   }
15107
15108 }
15109
15110
15111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15112   void * jresult ;
15113   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15114   Dali::Property::Value *arg2 = 0 ;
15115   Dali::Property::Array *result = 0 ;
15116
15117   arg1 = (Dali::Property::Array *)jarg1;
15118   arg2 = (Dali::Property::Value *)jarg2;
15119   if (!arg2) {
15120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15121     return 0;
15122   }
15123   {
15124     try {
15125       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15126     } catch (std::out_of_range& e) {
15127       {
15128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15129       };
15130     } catch (std::exception& e) {
15131       {
15132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15133       };
15134     } catch (Dali::DaliException e) {
15135       {
15136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15137       };
15138     } catch (...) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15141       };
15142     }
15143   }
15144
15145   jresult = (void *)result;
15146   return jresult;
15147 }
15148
15149
15150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15151   void * jresult ;
15152   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15153   Dali::Property::Array::SizeType arg2 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15176       };
15177     }
15178   }
15179
15180   jresult = (void *)result;
15181   return jresult;
15182 }
15183
15184
15185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15186   void * jresult ;
15187   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15188   Dali::Property::Array::SizeType arg2 ;
15189   Dali::Property::Value *result = 0 ;
15190
15191   arg1 = (Dali::Property::Array *)jarg1;
15192   arg2 = (Dali::Property::Array::SizeType)jarg2;
15193   {
15194     try {
15195       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15196     } catch (std::out_of_range& e) {
15197       {
15198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (std::exception& e) {
15201       {
15202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15203       };
15204     } catch (Dali::DaliException e) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15211       };
15212     }
15213   }
15214
15215   jresult = (void *)result;
15216   return jresult;
15217 }
15218
15219
15220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15221   void * jresult ;
15222   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15223   Dali::Property::Array *arg2 = 0 ;
15224   Dali::Property::Array *result = 0 ;
15225
15226   arg1 = (Dali::Property::Array *)jarg1;
15227   arg2 = (Dali::Property::Array *)jarg2;
15228   if (!arg2) {
15229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15230     return 0;
15231   }
15232   {
15233     try {
15234       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15235     } catch (std::out_of_range& e) {
15236       {
15237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15238       };
15239     } catch (std::exception& e) {
15240       {
15241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15242       };
15243     } catch (Dali::DaliException e) {
15244       {
15245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15246       };
15247     } catch (...) {
15248       {
15249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15250       };
15251     }
15252   }
15253
15254   jresult = (void *)result;
15255   return jresult;
15256 }
15257
15258
15259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15260   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15261   enum Dali::Property::Key::Type arg2 ;
15262
15263   arg1 = (Dali::Property::Key *)jarg1;
15264   arg2 = (enum Dali::Property::Key::Type)jarg2;
15265   if (arg1) (arg1)->type = arg2;
15266 }
15267
15268
15269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15270   int jresult ;
15271   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15272   enum Dali::Property::Key::Type result;
15273
15274   arg1 = (Dali::Property::Key *)jarg1;
15275   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15276   jresult = (int)result;
15277   return jresult;
15278 }
15279
15280
15281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15282   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15283   Dali::Property::Index arg2 ;
15284
15285   arg1 = (Dali::Property::Key *)jarg1;
15286   arg2 = (Dali::Property::Index)jarg2;
15287   if (arg1) (arg1)->indexKey = arg2;
15288 }
15289
15290
15291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15292   int jresult ;
15293   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15294   Dali::Property::Index result;
15295
15296   arg1 = (Dali::Property::Key *)jarg1;
15297   result = (Dali::Property::Index) ((arg1)->indexKey);
15298   jresult = result;
15299   return jresult;
15300 }
15301
15302
15303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15304   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15305   std::string *arg2 = 0 ;
15306
15307   arg1 = (Dali::Property::Key *)jarg1;
15308   if (!jarg2) {
15309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15310     return ;
15311   }
15312   std::string arg2_str(jarg2);
15313   arg2 = &arg2_str;
15314   if (arg1) (arg1)->stringKey = *arg2;
15315
15316   //argout typemap for const std::string&
15317
15318 }
15319
15320
15321 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15322   char * jresult ;
15323   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15324   std::string *result = 0 ;
15325
15326   arg1 = (Dali::Property::Key *)jarg1;
15327   result = (std::string *) & ((arg1)->stringKey);
15328   jresult = SWIG_csharp_string_callback(result->c_str());
15329   return jresult;
15330 }
15331
15332
15333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15334   void * jresult ;
15335   std::string *arg1 = 0 ;
15336   Dali::Property::Key *result = 0 ;
15337
15338   if (!jarg1) {
15339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15340     return 0;
15341   }
15342   std::string arg1_str(jarg1);
15343   arg1 = &arg1_str;
15344   {
15345     try {
15346       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15347     } catch (std::out_of_range& e) {
15348       {
15349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15350       };
15351     } catch (std::exception& e) {
15352       {
15353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15354       };
15355     } catch (Dali::DaliException e) {
15356       {
15357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15358       };
15359     } catch (...) {
15360       {
15361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15362       };
15363     }
15364   }
15365
15366   jresult = (void *)result;
15367
15368   //argout typemap for const std::string&
15369
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15375   void * jresult ;
15376   Dali::Property::Index arg1 ;
15377   Dali::Property::Key *result = 0 ;
15378
15379   arg1 = (Dali::Property::Index)jarg1;
15380   {
15381     try {
15382       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15383     } catch (std::out_of_range& e) {
15384       {
15385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15386       };
15387     } catch (std::exception& e) {
15388       {
15389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15390       };
15391     } catch (Dali::DaliException e) {
15392       {
15393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15394       };
15395     } catch (...) {
15396       {
15397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15398       };
15399     }
15400   }
15401
15402   jresult = (void *)result;
15403   return jresult;
15404 }
15405
15406
15407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15408   unsigned int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   std::string *arg2 = 0 ;
15411   bool result;
15412
15413   arg1 = (Dali::Property::Key *)jarg1;
15414   if (!jarg2) {
15415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15416     return 0;
15417   }
15418   std::string arg2_str(jarg2);
15419   arg2 = &arg2_str;
15420   {
15421     try {
15422       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15423     } catch (std::out_of_range& e) {
15424       {
15425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15426       };
15427     } catch (std::exception& e) {
15428       {
15429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15430       };
15431     } catch (Dali::DaliException e) {
15432       {
15433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15434       };
15435     } catch (...) {
15436       {
15437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15438       };
15439     }
15440   }
15441
15442   jresult = result;
15443
15444   //argout typemap for const std::string&
15445
15446   return jresult;
15447 }
15448
15449
15450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15451   unsigned int jresult ;
15452   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15453   Dali::Property::Index arg2 ;
15454   bool result;
15455
15456   arg1 = (Dali::Property::Key *)jarg1;
15457   arg2 = (Dali::Property::Index)jarg2;
15458   {
15459     try {
15460       result = (bool)(arg1)->operator ==(arg2);
15461     } catch (std::out_of_range& e) {
15462       {
15463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15464       };
15465     } catch (std::exception& e) {
15466       {
15467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15468       };
15469     } catch (Dali::DaliException e) {
15470       {
15471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15472       };
15473     } catch (...) {
15474       {
15475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15476       };
15477     }
15478   }
15479
15480   jresult = result;
15481   return jresult;
15482 }
15483
15484
15485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15486   unsigned int jresult ;
15487   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15488   Dali::Property::Key *arg2 = 0 ;
15489   bool result;
15490
15491   arg1 = (Dali::Property::Key *)jarg1;
15492   arg2 = (Dali::Property::Key *)jarg2;
15493   if (!arg2) {
15494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15495     return 0;
15496   }
15497   {
15498     try {
15499       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15500     } catch (std::out_of_range& e) {
15501       {
15502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15503       };
15504     } catch (std::exception& e) {
15505       {
15506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15507       };
15508     } catch (Dali::DaliException e) {
15509       {
15510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15511       };
15512     } catch (...) {
15513       {
15514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15515       };
15516     }
15517   }
15518
15519   jresult = result;
15520   return jresult;
15521 }
15522
15523
15524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15525   unsigned int jresult ;
15526   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15527   std::string *arg2 = 0 ;
15528   bool result;
15529
15530   arg1 = (Dali::Property::Key *)jarg1;
15531   if (!jarg2) {
15532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15533     return 0;
15534   }
15535   std::string arg2_str(jarg2);
15536   arg2 = &arg2_str;
15537   {
15538     try {
15539       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15540     } catch (std::out_of_range& e) {
15541       {
15542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (std::exception& e) {
15545       {
15546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15547       };
15548     } catch (Dali::DaliException e) {
15549       {
15550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15551       };
15552     } catch (...) {
15553       {
15554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15555       };
15556     }
15557   }
15558
15559   jresult = result;
15560
15561   //argout typemap for const std::string&
15562
15563   return jresult;
15564 }
15565
15566
15567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15568   unsigned int jresult ;
15569   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15570   Dali::Property::Index arg2 ;
15571   bool result;
15572
15573   arg1 = (Dali::Property::Key *)jarg1;
15574   arg2 = (Dali::Property::Index)jarg2;
15575   {
15576     try {
15577       result = (bool)(arg1)->operator !=(arg2);
15578     } catch (std::out_of_range& e) {
15579       {
15580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15581       };
15582     } catch (std::exception& e) {
15583       {
15584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15585       };
15586     } catch (Dali::DaliException e) {
15587       {
15588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15589       };
15590     } catch (...) {
15591       {
15592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15593       };
15594     }
15595   }
15596
15597   jresult = result;
15598   return jresult;
15599 }
15600
15601
15602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15603   unsigned int jresult ;
15604   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15605   Dali::Property::Key *arg2 = 0 ;
15606   bool result;
15607
15608   arg1 = (Dali::Property::Key *)jarg1;
15609   arg2 = (Dali::Property::Key *)jarg2;
15610   if (!arg2) {
15611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15612     return 0;
15613   }
15614   {
15615     try {
15616       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15617     } catch (std::out_of_range& e) {
15618       {
15619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15620       };
15621     } catch (std::exception& e) {
15622       {
15623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15624       };
15625     } catch (Dali::DaliException e) {
15626       {
15627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15628       };
15629     } catch (...) {
15630       {
15631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15632       };
15633     }
15634   }
15635
15636   jresult = result;
15637   return jresult;
15638 }
15639
15640
15641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15642   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15643
15644   arg1 = (Dali::Property::Key *)jarg1;
15645   {
15646     try {
15647       delete arg1;
15648     } catch (std::out_of_range& e) {
15649       {
15650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15651       };
15652     } catch (std::exception& e) {
15653       {
15654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15655       };
15656     } catch (Dali::DaliException e) {
15657       {
15658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15659       };
15660     } catch (...) {
15661       {
15662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15663       };
15664     }
15665   }
15666
15667 }
15668
15669
15670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15671   void * jresult ;
15672   Dali::Property::Map *result = 0 ;
15673
15674   {
15675     try {
15676       result = (Dali::Property::Map *)new Dali::Property::Map();
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (Dali::DaliException e) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15688       };
15689     } catch (...) {
15690       {
15691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15692       };
15693     }
15694   }
15695
15696   jresult = (void *)result;
15697   return jresult;
15698 }
15699
15700
15701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15702   void * jresult ;
15703   Dali::Property::Map *arg1 = 0 ;
15704   Dali::Property::Map *result = 0 ;
15705
15706   arg1 = (Dali::Property::Map *)jarg1;
15707   if (!arg1) {
15708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15709     return 0;
15710   }
15711   {
15712     try {
15713       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15714     } catch (std::out_of_range& e) {
15715       {
15716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (std::exception& e) {
15719       {
15720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (Dali::DaliException e) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15725       };
15726     } catch (...) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15729       };
15730     }
15731   }
15732
15733   jresult = (void *)result;
15734   return jresult;
15735 }
15736
15737
15738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15739   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15740
15741   arg1 = (Dali::Property::Map *)jarg1;
15742   {
15743     try {
15744       delete arg1;
15745     } catch (std::out_of_range& e) {
15746       {
15747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15748       };
15749     } catch (std::exception& e) {
15750       {
15751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15752       };
15753     } catch (Dali::DaliException e) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15756       };
15757     } catch (...) {
15758       {
15759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15760       };
15761     }
15762   }
15763
15764 }
15765
15766
15767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15768   unsigned long jresult ;
15769   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15770   Dali::Property::Map::SizeType result;
15771
15772   arg1 = (Dali::Property::Map *)jarg1;
15773   {
15774     try {
15775       result = ((Dali::Property::Map const *)arg1)->Count();
15776     } catch (std::out_of_range& e) {
15777       {
15778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15779       };
15780     } catch (std::exception& e) {
15781       {
15782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15783       };
15784     } catch (Dali::DaliException e) {
15785       {
15786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15787       };
15788     } catch (...) {
15789       {
15790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15791       };
15792     }
15793   }
15794
15795   jresult = (unsigned long)result;
15796   return jresult;
15797 }
15798
15799
15800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15801   unsigned int jresult ;
15802   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15803   bool result;
15804
15805   arg1 = (Dali::Property::Map *)jarg1;
15806   {
15807     try {
15808       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15809     } catch (std::out_of_range& e) {
15810       {
15811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (std::exception& e) {
15814       {
15815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (Dali::DaliException e) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827
15828   jresult = result;
15829   return jresult;
15830 }
15831
15832
15833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15834   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15835   char *arg2 = (char *) 0 ;
15836   Dali::Property::Value *arg3 = 0 ;
15837
15838   arg1 = (Dali::Property::Map *)jarg1;
15839   arg2 = (char *)jarg2;
15840   arg3 = (Dali::Property::Value *)jarg3;
15841   if (!arg3) {
15842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15843     return ;
15844   }
15845   {
15846     try {
15847       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15848     } catch (std::out_of_range& e) {
15849       {
15850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15851       };
15852     } catch (std::exception& e) {
15853       {
15854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15855       };
15856     } catch (Dali::DaliException e) {
15857       {
15858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15859       };
15860     } catch (...) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15863       };
15864     }
15865   }
15866
15867 }
15868
15869
15870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15871   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15872   Dali::Property::Index arg2 ;
15873   Dali::Property::Value *arg3 = 0 ;
15874
15875   arg1 = (Dali::Property::Map *)jarg1;
15876   arg2 = (Dali::Property::Index)jarg2;
15877   arg3 = (Dali::Property::Value *)jarg3;
15878   if (!arg3) {
15879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15880     return ;
15881   }
15882   {
15883     try {
15884       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15908   void * jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   char *arg2 = (char *) 0 ;
15911   Dali::Property::Value *arg3 = 0 ;
15912   Dali::Property::Map *result = 0 ;
15913
15914   arg1 = (Dali::Property::Map *)jarg1;
15915   arg2 = (char *)jarg2;
15916   arg3 = (Dali::Property::Value *)jarg3;
15917   if (!arg3) {
15918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15919     return 0;
15920   }
15921   {
15922     try {
15923       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
15924     } catch (std::out_of_range& e) {
15925       {
15926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15927       };
15928     } catch (std::exception& e) {
15929       {
15930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15931       };
15932     } catch (Dali::DaliException e) {
15933       {
15934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15935       };
15936     } catch (...) {
15937       {
15938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15939       };
15940     }
15941   }
15942
15943   jresult = (void *)result;
15944   return jresult;
15945 }
15946
15947
15948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15949   void * jresult ;
15950   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15951   Dali::Property::Index arg2 ;
15952   Dali::Property::Value *arg3 = 0 ;
15953   Dali::Property::Map *result = 0 ;
15954
15955   arg1 = (Dali::Property::Map *)jarg1;
15956   arg2 = (Dali::Property::Index)jarg2;
15957   arg3 = (Dali::Property::Value *)jarg3;
15958   if (!arg3) {
15959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15960     return 0;
15961   }
15962   {
15963     try {
15964       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
15965     } catch (std::out_of_range& e) {
15966       {
15967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15968       };
15969     } catch (std::exception& e) {
15970       {
15971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15972       };
15973     } catch (Dali::DaliException e) {
15974       {
15975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15976       };
15977     } catch (...) {
15978       {
15979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15980       };
15981     }
15982   }
15983
15984   jresult = (void *)result;
15985   return jresult;
15986 }
15987
15988
15989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
15990   void * jresult ;
15991   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15992   Dali::Property::Map::SizeType arg2 ;
15993   Dali::Property::Value *result = 0 ;
15994
15995   arg1 = (Dali::Property::Map *)jarg1;
15996   arg2 = (Dali::Property::Map::SizeType)jarg2;
15997   {
15998     try {
15999       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16000     } catch (std::out_of_range& e) {
16001       {
16002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16003       };
16004     } catch (std::exception& e) {
16005       {
16006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16007       };
16008     } catch (Dali::DaliException e) {
16009       {
16010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16011       };
16012     } catch (...) {
16013       {
16014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16015       };
16016     }
16017   }
16018
16019   jresult = (void *)result;
16020   return jresult;
16021 }
16022
16023
16024 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16025   char * jresult ;
16026   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16027   Dali::Property::Map::SizeType arg2 ;
16028   std::string *result = 0 ;
16029
16030   arg1 = (Dali::Property::Map *)jarg1;
16031   arg2 = (Dali::Property::Map::SizeType)jarg2;
16032   {
16033     try {
16034       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16035     } catch (std::out_of_range& e) {
16036       {
16037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16038       };
16039     } catch (std::exception& e) {
16040       {
16041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16042       };
16043     } catch (Dali::DaliException e) {
16044       {
16045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16046       };
16047     } catch (...) {
16048       {
16049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16050       };
16051     }
16052   }
16053
16054   jresult = SWIG_csharp_string_callback(result->c_str());
16055   return jresult;
16056 }
16057
16058
16059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16060   void * jresult ;
16061   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16062   Dali::Property::Map::SizeType arg2 ;
16063   SwigValueWrapper< Dali::Property::Key > result;
16064
16065   arg1 = (Dali::Property::Map *)jarg1;
16066   arg2 = (Dali::Property::Map::SizeType)jarg2;
16067   {
16068     try {
16069       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16070     } catch (std::out_of_range& e) {
16071       {
16072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16073       };
16074     } catch (std::exception& e) {
16075       {
16076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16077       };
16078     } catch (Dali::DaliException e) {
16079       {
16080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16081       };
16082     } catch (...) {
16083       {
16084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16085       };
16086     }
16087   }
16088
16089   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16090   return jresult;
16091 }
16092
16093
16094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16095   void * jresult ;
16096   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16097   Dali::Property::Map::SizeType arg2 ;
16098   StringValuePair *result = 0 ;
16099
16100   arg1 = (Dali::Property::Map *)jarg1;
16101   arg2 = (Dali::Property::Map::SizeType)jarg2;
16102   {
16103     try {
16104       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   char *arg2 = (char *) 0 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (char *)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16165   void * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Index arg2 ;
16168   Dali::Property::Value *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Index)jarg2;
16172   {
16173     try {
16174       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = (void *)result;
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Index arg2 ;
16203   std::string *arg3 = 0 ;
16204   Dali::Property::Value *result = 0 ;
16205
16206   arg1 = (Dali::Property::Map *)jarg1;
16207   arg2 = (Dali::Property::Index)jarg2;
16208   if (!jarg3) {
16209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16210     return 0;
16211   }
16212   std::string arg3_str(jarg3);
16213   arg3 = &arg3_str;
16214   {
16215     try {
16216       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16217     } catch (std::out_of_range& e) {
16218       {
16219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16220       };
16221     } catch (std::exception& e) {
16222       {
16223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (Dali::DaliException e) {
16226       {
16227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16228       };
16229     } catch (...) {
16230       {
16231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16232       };
16233     }
16234   }
16235
16236   jresult = (void *)result;
16237
16238   //argout typemap for const std::string&
16239
16240   return jresult;
16241 }
16242
16243
16244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16245   void * jresult ;
16246   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16247   std::string *arg2 = 0 ;
16248   Dali::Property::Type arg3 ;
16249   Dali::Property::Value *result = 0 ;
16250
16251   arg1 = (Dali::Property::Map *)jarg1;
16252   if (!jarg2) {
16253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16254     return 0;
16255   }
16256   std::string arg2_str(jarg2);
16257   arg2 = &arg2_str;
16258   arg3 = (Dali::Property::Type)jarg3;
16259   {
16260     try {
16261       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16262     } catch (std::out_of_range& e) {
16263       {
16264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16265       };
16266     } catch (std::exception& e) {
16267       {
16268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16269       };
16270     } catch (Dali::DaliException e) {
16271       {
16272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16273       };
16274     } catch (...) {
16275       {
16276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16277       };
16278     }
16279   }
16280
16281   jresult = (void *)result;
16282
16283   //argout typemap for const std::string&
16284
16285   return jresult;
16286 }
16287
16288
16289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16290   void * jresult ;
16291   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16292   Dali::Property::Index arg2 ;
16293   Dali::Property::Type arg3 ;
16294   Dali::Property::Value *result = 0 ;
16295
16296   arg1 = (Dali::Property::Map *)jarg1;
16297   arg2 = (Dali::Property::Index)jarg2;
16298   arg3 = (Dali::Property::Type)jarg3;
16299   {
16300     try {
16301       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16302     } catch (std::out_of_range& e) {
16303       {
16304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16305       };
16306     } catch (std::exception& e) {
16307       {
16308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (Dali::DaliException e) {
16311       {
16312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16313       };
16314     } catch (...) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16317       };
16318     }
16319   }
16320
16321   jresult = (void *)result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16327   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16328
16329   arg1 = (Dali::Property::Map *)jarg1;
16330   {
16331     try {
16332       (arg1)->Clear();
16333     } catch (std::out_of_range& e) {
16334       {
16335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16336       };
16337     } catch (std::exception& e) {
16338       {
16339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16340       };
16341     } catch (Dali::DaliException e) {
16342       {
16343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16344       };
16345     } catch (...) {
16346       {
16347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16348       };
16349     }
16350   }
16351
16352 }
16353
16354
16355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16356   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16357   Dali::Property::Map *arg2 = 0 ;
16358
16359   arg1 = (Dali::Property::Map *)jarg1;
16360   arg2 = (Dali::Property::Map *)jarg2;
16361   if (!arg2) {
16362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16363     return ;
16364   }
16365   {
16366     try {
16367       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16368     } catch (std::out_of_range& e) {
16369       {
16370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16371       };
16372     } catch (std::exception& e) {
16373       {
16374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16375       };
16376     } catch (Dali::DaliException e) {
16377       {
16378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16379       };
16380     } catch (...) {
16381       {
16382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16383       };
16384     }
16385   }
16386
16387 }
16388
16389
16390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16391   void * jresult ;
16392   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16393   std::string *arg2 = 0 ;
16394   Dali::Property::Value *result = 0 ;
16395
16396   arg1 = (Dali::Property::Map *)jarg1;
16397   if (!jarg2) {
16398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16399     return 0;
16400   }
16401   std::string arg2_str(jarg2);
16402   arg2 = &arg2_str;
16403   {
16404     try {
16405       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16406     } catch (std::out_of_range& e) {
16407       {
16408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (std::exception& e) {
16411       {
16412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16413       };
16414     } catch (Dali::DaliException e) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16417       };
16418     } catch (...) {
16419       {
16420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16421       };
16422     }
16423   }
16424
16425   jresult = (void *)result;
16426
16427   //argout typemap for const std::string&
16428
16429   return jresult;
16430 }
16431
16432
16433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16434   void * jresult ;
16435   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16436   Dali::Property::Index arg2 ;
16437   Dali::Property::Value *result = 0 ;
16438
16439   arg1 = (Dali::Property::Map *)jarg1;
16440   arg2 = (Dali::Property::Index)jarg2;
16441   {
16442     try {
16443       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16444     } catch (std::out_of_range& e) {
16445       {
16446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (std::exception& e) {
16449       {
16450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16451       };
16452     } catch (Dali::DaliException e) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16455       };
16456     } catch (...) {
16457       {
16458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16459       };
16460     }
16461   }
16462
16463   jresult = (void *)result;
16464   return jresult;
16465 }
16466
16467
16468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16469   void * jresult ;
16470   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16471   Dali::Property::Map *arg2 = 0 ;
16472   Dali::Property::Map *result = 0 ;
16473
16474   arg1 = (Dali::Property::Map *)jarg1;
16475   arg2 = (Dali::Property::Map *)jarg2;
16476   if (!arg2) {
16477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16478     return 0;
16479   }
16480   {
16481     try {
16482       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16483     } catch (std::out_of_range& e) {
16484       {
16485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16486       };
16487     } catch (std::exception& e) {
16488       {
16489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16490       };
16491     } catch (Dali::DaliException e) {
16492       {
16493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16494       };
16495     } catch (...) {
16496       {
16497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16498       };
16499     }
16500   }
16501
16502   jresult = (void *)result;
16503   return jresult;
16504 }
16505
16506
16507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16508   void * jresult ;
16509   Dali::Property::Value *result = 0 ;
16510
16511   {
16512     try {
16513       result = (Dali::Property::Value *)new Dali::Property::Value();
16514     } catch (std::out_of_range& e) {
16515       {
16516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16517       };
16518     } catch (std::exception& e) {
16519       {
16520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16521       };
16522     } catch (Dali::DaliException e) {
16523       {
16524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16525       };
16526     } catch (...) {
16527       {
16528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16529       };
16530     }
16531   }
16532
16533   jresult = (void *)result;
16534   return jresult;
16535 }
16536
16537
16538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16539   void * jresult ;
16540   bool arg1 ;
16541   Dali::Property::Value *result = 0 ;
16542
16543   arg1 = jarg1 ? true : false;
16544   {
16545     try {
16546       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16547     } catch (std::out_of_range& e) {
16548       {
16549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (std::exception& e) {
16552       {
16553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (Dali::DaliException e) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16558       };
16559     } catch (...) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16562       };
16563     }
16564   }
16565
16566   jresult = (void *)result;
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16572   void * jresult ;
16573   int arg1 ;
16574   Dali::Property::Value *result = 0 ;
16575
16576   arg1 = (int)jarg1;
16577   {
16578     try {
16579       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16580     } catch (std::out_of_range& e) {
16581       {
16582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (std::exception& e) {
16585       {
16586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (Dali::DaliException e) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16591       };
16592     } catch (...) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16595       };
16596     }
16597   }
16598
16599   jresult = (void *)result;
16600   return jresult;
16601 }
16602
16603
16604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16605   void * jresult ;
16606   float arg1 ;
16607   Dali::Property::Value *result = 0 ;
16608
16609   arg1 = (float)jarg1;
16610   {
16611     try {
16612       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16613     } catch (std::out_of_range& e) {
16614       {
16615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16616       };
16617     } catch (std::exception& e) {
16618       {
16619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16620       };
16621     } catch (Dali::DaliException e) {
16622       {
16623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16624       };
16625     } catch (...) {
16626       {
16627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16628       };
16629     }
16630   }
16631
16632   jresult = (void *)result;
16633   return jresult;
16634 }
16635
16636
16637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16638   void * jresult ;
16639   Dali::Vector2 *arg1 = 0 ;
16640   Dali::Property::Value *result = 0 ;
16641
16642   arg1 = (Dali::Vector2 *)jarg1;
16643   if (!arg1) {
16644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16645     return 0;
16646   }
16647   {
16648     try {
16649       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16650     } catch (std::out_of_range& e) {
16651       {
16652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16653       };
16654     } catch (std::exception& e) {
16655       {
16656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (Dali::DaliException e) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16661       };
16662     } catch (...) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16665       };
16666     }
16667   }
16668
16669   jresult = (void *)result;
16670   return jresult;
16671 }
16672
16673
16674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16675   void * jresult ;
16676   Dali::Vector3 *arg1 = 0 ;
16677   Dali::Property::Value *result = 0 ;
16678
16679   arg1 = (Dali::Vector3 *)jarg1;
16680   if (!arg1) {
16681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16682     return 0;
16683   }
16684   {
16685     try {
16686       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16712   void * jresult ;
16713   Dali::Vector4 *arg1 = 0 ;
16714   Dali::Property::Value *result = 0 ;
16715
16716   arg1 = (Dali::Vector4 *)jarg1;
16717   if (!arg1) {
16718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16719     return 0;
16720   }
16721   {
16722     try {
16723       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16724     } catch (std::out_of_range& e) {
16725       {
16726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (std::exception& e) {
16729       {
16730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16731       };
16732     } catch (Dali::DaliException e) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16735       };
16736     } catch (...) {
16737       {
16738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16739       };
16740     }
16741   }
16742
16743   jresult = (void *)result;
16744   return jresult;
16745 }
16746
16747
16748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16749   void * jresult ;
16750   Dali::Matrix3 *arg1 = 0 ;
16751   Dali::Property::Value *result = 0 ;
16752
16753   arg1 = (Dali::Matrix3 *)jarg1;
16754   if (!arg1) {
16755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16756     return 0;
16757   }
16758   {
16759     try {
16760       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16761     } catch (std::out_of_range& e) {
16762       {
16763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16764       };
16765     } catch (std::exception& e) {
16766       {
16767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16768       };
16769     } catch (Dali::DaliException e) {
16770       {
16771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16772       };
16773     } catch (...) {
16774       {
16775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16776       };
16777     }
16778   }
16779
16780   jresult = (void *)result;
16781   return jresult;
16782 }
16783
16784
16785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16786   void * jresult ;
16787   Dali::Matrix *arg1 = 0 ;
16788   Dali::Property::Value *result = 0 ;
16789
16790   arg1 = (Dali::Matrix *)jarg1;
16791   if (!arg1) {
16792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16793     return 0;
16794   }
16795   {
16796     try {
16797       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16798     } catch (std::out_of_range& e) {
16799       {
16800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16801       };
16802     } catch (std::exception& e) {
16803       {
16804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16805       };
16806     } catch (Dali::DaliException e) {
16807       {
16808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16809       };
16810     } catch (...) {
16811       {
16812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16813       };
16814     }
16815   }
16816
16817   jresult = (void *)result;
16818   return jresult;
16819 }
16820
16821
16822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16823   void * jresult ;
16824   Dali::Rect< int > *arg1 = 0 ;
16825   Dali::Property::Value *result = 0 ;
16826
16827   arg1 = (Dali::Rect< int > *)jarg1;
16828   if (!arg1) {
16829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16830     return 0;
16831   }
16832   {
16833     try {
16834       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16835     } catch (std::out_of_range& e) {
16836       {
16837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16838       };
16839     } catch (std::exception& e) {
16840       {
16841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16842       };
16843     } catch (Dali::DaliException e) {
16844       {
16845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16846       };
16847     } catch (...) {
16848       {
16849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16850       };
16851     }
16852   }
16853
16854   jresult = (void *)result;
16855   return jresult;
16856 }
16857
16858
16859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16860   void * jresult ;
16861   Dali::AngleAxis *arg1 = 0 ;
16862   Dali::Property::Value *result = 0 ;
16863
16864   arg1 = (Dali::AngleAxis *)jarg1;
16865   if (!arg1) {
16866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
16867     return 0;
16868   }
16869   {
16870     try {
16871       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
16872     } catch (std::out_of_range& e) {
16873       {
16874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16875       };
16876     } catch (std::exception& e) {
16877       {
16878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16879       };
16880     } catch (Dali::DaliException e) {
16881       {
16882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16883       };
16884     } catch (...) {
16885       {
16886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16887       };
16888     }
16889   }
16890
16891   jresult = (void *)result;
16892   return jresult;
16893 }
16894
16895
16896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
16897   void * jresult ;
16898   Dali::Quaternion *arg1 = 0 ;
16899   Dali::Property::Value *result = 0 ;
16900
16901   arg1 = (Dali::Quaternion *)jarg1;
16902   if (!arg1) {
16903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
16904     return 0;
16905   }
16906   {
16907     try {
16908       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
16909     } catch (std::out_of_range& e) {
16910       {
16911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16912       };
16913     } catch (std::exception& e) {
16914       {
16915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16916       };
16917     } catch (Dali::DaliException e) {
16918       {
16919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16920       };
16921     } catch (...) {
16922       {
16923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16924       };
16925     }
16926   }
16927
16928   jresult = (void *)result;
16929   return jresult;
16930 }
16931
16932
16933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
16934   void * jresult ;
16935   std::string *arg1 = 0 ;
16936   Dali::Property::Value *result = 0 ;
16937
16938   if (!jarg1) {
16939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16940     return 0;
16941   }
16942   std::string arg1_str(jarg1);
16943   arg1 = &arg1_str;
16944   {
16945     try {
16946       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
16947     } catch (std::out_of_range& e) {
16948       {
16949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16950       };
16951     } catch (std::exception& e) {
16952       {
16953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16954       };
16955     } catch (Dali::DaliException e) {
16956       {
16957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16958       };
16959     } catch (...) {
16960       {
16961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16962       };
16963     }
16964   }
16965
16966   jresult = (void *)result;
16967
16968   //argout typemap for const std::string&
16969
16970   return jresult;
16971 }
16972
16973
16974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
16975   void * jresult ;
16976   Dali::Property::Array *arg1 = 0 ;
16977   Dali::Property::Value *result = 0 ;
16978
16979   arg1 = (Dali::Property::Array *)jarg1;
16980   if (!arg1) {
16981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
16982     return 0;
16983   }
16984   {
16985     try {
16986       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
16987     } catch (std::out_of_range& e) {
16988       {
16989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16990       };
16991     } catch (std::exception& e) {
16992       {
16993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (Dali::DaliException e) {
16996       {
16997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16998       };
16999     } catch (...) {
17000       {
17001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17002       };
17003     }
17004   }
17005
17006   jresult = (void *)result;
17007   return jresult;
17008 }
17009
17010
17011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17012   void * jresult ;
17013   Dali::Property::Map *arg1 = 0 ;
17014   Dali::Property::Value *result = 0 ;
17015
17016   arg1 = (Dali::Property::Map *)jarg1;
17017   if (!arg1) {
17018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17019     return 0;
17020   }
17021   {
17022     try {
17023       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17024     } catch (std::out_of_range& e) {
17025       {
17026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17027       };
17028     } catch (std::exception& e) {
17029       {
17030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17031       };
17032     } catch (Dali::DaliException e) {
17033       {
17034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17035       };
17036     } catch (...) {
17037       {
17038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17039       };
17040     }
17041   }
17042
17043   jresult = (void *)result;
17044   return jresult;
17045 }
17046
17047
17048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17049   void * jresult ;
17050   Extents *arg1 = 0 ;
17051   Dali::Property::Value *result = 0 ;
17052
17053   arg1 = (Extents *)jarg1;
17054   if (!arg1) {
17055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17056     return 0;
17057   }
17058   {
17059     try {
17060       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17061     } catch (std::out_of_range& e) {
17062       {
17063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17064       };
17065     } catch (std::exception& e) {
17066       {
17067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17068       };
17069     } catch (...) {
17070       {
17071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17072       };
17073     }
17074   }
17075   jresult = (void *)result;
17076   return jresult;
17077 }
17078
17079
17080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17081   void * jresult ;
17082   Dali::Property::Type arg1 ;
17083   Dali::Property::Value *result = 0 ;
17084
17085   arg1 = (Dali::Property::Type)jarg1;
17086   {
17087     try {
17088       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17089     } catch (std::out_of_range& e) {
17090       {
17091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17092       };
17093     } catch (std::exception& e) {
17094       {
17095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17096       };
17097     } catch (Dali::DaliException e) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17100       };
17101     } catch (...) {
17102       {
17103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17104       };
17105     }
17106   }
17107
17108   jresult = (void *)result;
17109   return jresult;
17110 }
17111
17112
17113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17114   void * jresult ;
17115   Dali::Property::Value *arg1 = 0 ;
17116   Dali::Property::Value *result = 0 ;
17117
17118   arg1 = (Dali::Property::Value *)jarg1;
17119   if (!arg1) {
17120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17121     return 0;
17122   }
17123   {
17124     try {
17125       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17126     } catch (std::out_of_range& e) {
17127       {
17128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17129       };
17130     } catch (std::exception& e) {
17131       {
17132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (Dali::DaliException e) {
17135       {
17136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17137       };
17138     } catch (...) {
17139       {
17140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17141       };
17142     }
17143   }
17144
17145   jresult = (void *)result;
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17151   void * jresult ;
17152   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17153   Dali::Property::Value *arg2 = 0 ;
17154   Dali::Property::Value *result = 0 ;
17155
17156   arg1 = (Dali::Property::Value *)jarg1;
17157   arg2 = (Dali::Property::Value *)jarg2;
17158   if (!arg2) {
17159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17160     return 0;
17161   }
17162   {
17163     try {
17164       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17165     } catch (std::out_of_range& e) {
17166       {
17167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (std::exception& e) {
17170       {
17171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17172       };
17173     } catch (Dali::DaliException e) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17176       };
17177     } catch (...) {
17178       {
17179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17180       };
17181     }
17182   }
17183
17184   jresult = (void *)result;
17185   return jresult;
17186 }
17187
17188
17189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17190   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17191
17192   arg1 = (Dali::Property::Value *)jarg1;
17193   {
17194     try {
17195       delete arg1;
17196     } catch (std::out_of_range& e) {
17197       {
17198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17199       };
17200     } catch (std::exception& e) {
17201       {
17202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17203       };
17204     } catch (Dali::DaliException e) {
17205       {
17206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17207       };
17208     } catch (...) {
17209       {
17210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17211       };
17212     }
17213   }
17214
17215 }
17216
17217
17218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17219   int jresult ;
17220   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17221   Dali::Property::Type result;
17222
17223   arg1 = (Dali::Property::Value *)jarg1;
17224   {
17225     try {
17226       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (Dali::DaliException e) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245
17246   jresult = (int)result;
17247   return jresult;
17248 }
17249
17250
17251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17252   unsigned int jresult ;
17253   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17254   bool *arg2 = 0 ;
17255   bool result;
17256
17257   arg1 = (Dali::Property::Value *)jarg1;
17258   arg2 = (bool *)jarg2;
17259   {
17260     try {
17261       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17262     } catch (std::out_of_range& e) {
17263       {
17264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17265       };
17266     } catch (std::exception& e) {
17267       {
17268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (Dali::DaliException e) {
17271       {
17272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17273       };
17274     } catch (...) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17277       };
17278     }
17279   }
17280
17281   jresult = result;
17282   return jresult;
17283 }
17284
17285
17286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17287   unsigned int jresult ;
17288   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17289   float *arg2 = 0 ;
17290   bool result;
17291
17292   arg1 = (Dali::Property::Value *)jarg1;
17293   arg2 = (float *)jarg2;
17294   {
17295     try {
17296       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (Dali::DaliException e) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17308       };
17309     } catch (...) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17312       };
17313     }
17314   }
17315
17316   jresult = result;
17317   return jresult;
17318 }
17319
17320
17321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17322   unsigned int jresult ;
17323   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17324   int *arg2 = 0 ;
17325   bool result;
17326
17327   arg1 = (Dali::Property::Value *)jarg1;
17328   arg2 = (int *)jarg2;
17329   {
17330     try {
17331       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17332     } catch (std::out_of_range& e) {
17333       {
17334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17335       };
17336     } catch (std::exception& e) {
17337       {
17338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17339       };
17340     } catch (Dali::DaliException e) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17343       };
17344     } catch (...) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17347       };
17348     }
17349   }
17350
17351   jresult = result;
17352   return jresult;
17353 }
17354
17355
17356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17357   unsigned int jresult ;
17358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17359   Dali::Rect< int > *arg2 = 0 ;
17360   bool result;
17361
17362   arg1 = (Dali::Property::Value *)jarg1;
17363   arg2 = (Dali::Rect< int > *)jarg2;
17364   if (!arg2) {
17365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17366     return 0;
17367   }
17368   {
17369     try {
17370       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17371     } catch (std::out_of_range& e) {
17372       {
17373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (std::exception& e) {
17376       {
17377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17378       };
17379     } catch (Dali::DaliException e) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17382       };
17383     } catch (...) {
17384       {
17385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17386       };
17387     }
17388   }
17389
17390   jresult = result;
17391   return jresult;
17392 }
17393
17394
17395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17396   unsigned int jresult ;
17397   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17398   Dali::Vector2 *arg2 = 0 ;
17399   bool result;
17400
17401   arg1 = (Dali::Property::Value *)jarg1;
17402   arg2 = (Dali::Vector2 *)jarg2;
17403   if (!arg2) {
17404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17405     return 0;
17406   }
17407   {
17408     try {
17409       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
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 = result;
17430   return jresult;
17431 }
17432
17433
17434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17435   unsigned int jresult ;
17436   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17437   Dali::Vector3 *arg2 = 0 ;
17438   bool result;
17439
17440   arg1 = (Dali::Property::Value *)jarg1;
17441   arg2 = (Dali::Vector3 *)jarg2;
17442   if (!arg2) {
17443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17444     return 0;
17445   }
17446   {
17447     try {
17448       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17449     } catch (std::out_of_range& e) {
17450       {
17451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17452       };
17453     } catch (std::exception& e) {
17454       {
17455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (Dali::DaliException e) {
17458       {
17459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17460       };
17461     } catch (...) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17464       };
17465     }
17466   }
17467
17468   jresult = result;
17469   return jresult;
17470 }
17471
17472
17473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17474   unsigned int jresult ;
17475   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17476   Dali::Vector4 *arg2 = 0 ;
17477   bool result;
17478
17479   arg1 = (Dali::Property::Value *)jarg1;
17480   arg2 = (Dali::Vector4 *)jarg2;
17481   if (!arg2) {
17482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17483     return 0;
17484   }
17485   {
17486     try {
17487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17488     } catch (std::out_of_range& e) {
17489       {
17490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (std::exception& e) {
17493       {
17494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (Dali::DaliException e) {
17497       {
17498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17499       };
17500     } catch (...) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17503       };
17504     }
17505   }
17506
17507   jresult = result;
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17513   unsigned int jresult ;
17514   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17515   Dali::Matrix3 *arg2 = 0 ;
17516   bool result;
17517
17518   arg1 = (Dali::Property::Value *)jarg1;
17519   arg2 = (Dali::Matrix3 *)jarg2;
17520   if (!arg2) {
17521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17522     return 0;
17523   }
17524   {
17525     try {
17526       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17527     } catch (std::out_of_range& e) {
17528       {
17529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17530       };
17531     } catch (std::exception& e) {
17532       {
17533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17534       };
17535     } catch (Dali::DaliException e) {
17536       {
17537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17538       };
17539     } catch (...) {
17540       {
17541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17542       };
17543     }
17544   }
17545
17546   jresult = result;
17547   return jresult;
17548 }
17549
17550
17551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17552   unsigned int jresult ;
17553   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17554   Dali::Matrix *arg2 = 0 ;
17555   bool result;
17556
17557   arg1 = (Dali::Property::Value *)jarg1;
17558   arg2 = (Dali::Matrix *)jarg2;
17559   if (!arg2) {
17560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17561     return 0;
17562   }
17563   {
17564     try {
17565       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17566     } catch (std::out_of_range& e) {
17567       {
17568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (std::exception& e) {
17571       {
17572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (Dali::DaliException e) {
17575       {
17576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17577       };
17578     } catch (...) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17581       };
17582     }
17583   }
17584
17585   jresult = result;
17586   return jresult;
17587 }
17588
17589
17590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17591   unsigned int jresult ;
17592   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17593   Dali::AngleAxis *arg2 = 0 ;
17594   bool result;
17595
17596   arg1 = (Dali::Property::Value *)jarg1;
17597   arg2 = (Dali::AngleAxis *)jarg2;
17598   if (!arg2) {
17599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17600     return 0;
17601   }
17602   {
17603     try {
17604       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17605     } catch (std::out_of_range& e) {
17606       {
17607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (std::exception& e) {
17610       {
17611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (Dali::DaliException e) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17616       };
17617     } catch (...) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17620       };
17621     }
17622   }
17623
17624   jresult = result;
17625   return jresult;
17626 }
17627
17628
17629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17630   unsigned int jresult ;
17631   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17632   Dali::Quaternion *arg2 = 0 ;
17633   bool result;
17634
17635   arg1 = (Dali::Property::Value *)jarg1;
17636   arg2 = (Dali::Quaternion *)jarg2;
17637   if (!arg2) {
17638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17639     return 0;
17640   }
17641   {
17642     try {
17643       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17644     } catch (std::out_of_range& e) {
17645       {
17646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17647       };
17648     } catch (std::exception& e) {
17649       {
17650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17651       };
17652     } catch (Dali::DaliException e) {
17653       {
17654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17655       };
17656     } catch (...) {
17657       {
17658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17659       };
17660     }
17661   }
17662
17663   jresult = result;
17664   return jresult;
17665 }
17666
17667
17668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17669   unsigned int jresult ;
17670   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17671   std::string *arg2 = 0 ;
17672   bool result;
17673
17674   arg1 = (Dali::Property::Value *)jarg1;
17675
17676   //typemap in
17677   std::string temp;
17678   arg2 = &temp;
17679
17680   {
17681     try {
17682       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17683     } catch (std::out_of_range& e) {
17684       {
17685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (std::exception& e) {
17688       {
17689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17690       };
17691     } catch (Dali::DaliException e) {
17692       {
17693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17694       };
17695     } catch (...) {
17696       {
17697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17698       };
17699     }
17700   }
17701
17702   jresult = result;
17703
17704   //Typemap argout in c++ file.
17705   //This will convert c++ string to c# string
17706   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17707
17708   return jresult;
17709 }
17710
17711
17712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17713   unsigned int jresult ;
17714   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17715   Dali::Property::Array *arg2 = 0 ;
17716   bool result;
17717
17718   arg1 = (Dali::Property::Value *)jarg1;
17719   arg2 = (Dali::Property::Array *)jarg2;
17720   if (!arg2) {
17721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17722     return 0;
17723   }
17724   {
17725     try {
17726       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17727     } catch (std::out_of_range& e) {
17728       {
17729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17730       };
17731     } catch (std::exception& e) {
17732       {
17733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17734       };
17735     } catch (Dali::DaliException e) {
17736       {
17737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17738       };
17739     } catch (...) {
17740       {
17741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17742       };
17743     }
17744   }
17745
17746   jresult = result;
17747   return jresult;
17748 }
17749
17750
17751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17752   unsigned int jresult ;
17753   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17754   Dali::Property::Map *arg2 = 0 ;
17755   bool result;
17756
17757   arg1 = (Dali::Property::Value *)jarg1;
17758   arg2 = (Dali::Property::Map *)jarg2;
17759   if (!arg2) {
17760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17761     return 0;
17762   }
17763   {
17764     try {
17765       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17766     } catch (std::out_of_range& e) {
17767       {
17768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17769       };
17770     } catch (std::exception& e) {
17771       {
17772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17773       };
17774     } catch (Dali::DaliException e) {
17775       {
17776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17777       };
17778     } catch (...) {
17779       {
17780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17781       };
17782     }
17783   }
17784
17785   jresult = result;
17786   return jresult;
17787 }
17788
17789
17790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17791   unsigned int jresult ;
17792   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17793   Extents *arg2 = 0 ;
17794   bool result;
17795
17796   arg1 = (Dali::Property::Value *)jarg1;
17797   arg2 = (Extents *)jarg2;
17798   if (!arg2) {
17799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17800     return 0;
17801   }
17802   {
17803     try {
17804       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17805     } catch (std::out_of_range& e) {
17806       {
17807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17808       };
17809     } catch (std::exception& e) {
17810       {
17811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17812       };
17813     } catch (...) {
17814       {
17815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17816       };
17817     }
17818   }
17819   jresult = result;
17820   return jresult;
17821 }
17822
17823
17824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17825   void * jresult ;
17826   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17827   Dali::Property::Array *result = 0 ;
17828
17829   arg1 = (Dali::Property::Value *)jarg1;
17830   {
17831     try {
17832       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17833     } catch (std::out_of_range& e) {
17834       {
17835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17836       };
17837     } catch (std::exception& e) {
17838       {
17839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17840       };
17841     } catch (Dali::DaliException e) {
17842       {
17843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17844       };
17845     } catch (...) {
17846       {
17847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17848       };
17849     }
17850   }
17851
17852   jresult = (void *)result;
17853   return jresult;
17854 }
17855
17856
17857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17858   void * jresult ;
17859   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17860   Dali::Property::Map *result = 0 ;
17861
17862   arg1 = (Dali::Property::Value *)jarg1;
17863   {
17864     try {
17865       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
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 = (void *)result;
17886   return jresult;
17887 }
17888
17889
17890 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
17891   char * jresult ;
17892   Dali::Property::Type arg1 ;
17893   char *result = 0 ;
17894
17895   arg1 = (Dali::Property::Type)jarg1;
17896   {
17897     try {
17898       result = (char *)Dali::PropertyTypes::GetName(arg1);
17899     } catch (std::out_of_range& e) {
17900       {
17901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (std::exception& e) {
17904       {
17905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (Dali::DaliException e) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17910       };
17911     } catch (...) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17914       };
17915     }
17916   }
17917
17918   jresult = SWIG_csharp_string_callback((const char *)result);
17919   return jresult;
17920 }
17921
17922
17923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
17924   unsigned int jresult ;
17925   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17926   std::string *arg2 = 0 ;
17927   Dali::Property::Map *arg3 = 0 ;
17928   bool result;
17929
17930   arg1 = (Dali::BaseObject *)jarg1;
17931   if (!jarg2) {
17932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17933     return 0;
17934   }
17935   std::string arg2_str(jarg2);
17936   arg2 = &arg2_str;
17937   arg3 = (Dali::Property::Map *)jarg3;
17938   if (!arg3) {
17939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
17940     return 0;
17941   }
17942   {
17943     try {
17944       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
17945     } catch (std::out_of_range& e) {
17946       {
17947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (std::exception& e) {
17950       {
17951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (Dali::DaliException e) {
17954       {
17955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17956       };
17957     } catch (...) {
17958       {
17959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17960       };
17961     }
17962   }
17963
17964   jresult = result;
17965
17966   //argout typemap for const std::string&
17967
17968   return jresult;
17969 }
17970
17971
17972 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
17973   char * jresult ;
17974   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
17975   std::string *result = 0 ;
17976
17977   arg1 = (Dali::BaseObject *)jarg1;
17978   {
17979     try {
17980       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
17981     } catch (std::out_of_range& e) {
17982       {
17983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17984       };
17985     } catch (std::exception& e) {
17986       {
17987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17988       };
17989     } catch (Dali::DaliException e) {
17990       {
17991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17992       };
17993     } catch (...) {
17994       {
17995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17996       };
17997     }
17998   }
17999
18000   jresult = SWIG_csharp_string_callback(result->c_str());
18001   return jresult;
18002 }
18003
18004
18005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18006   unsigned int jresult ;
18007   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18008   Dali::TypeInfo *arg2 = 0 ;
18009   bool result;
18010
18011   arg1 = (Dali::BaseObject *)jarg1;
18012   arg2 = (Dali::TypeInfo *)jarg2;
18013   if (!arg2) {
18014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18015     return 0;
18016   }
18017   {
18018     try {
18019       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18020     } catch (std::out_of_range& e) {
18021       {
18022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18023       };
18024     } catch (std::exception& e) {
18025       {
18026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (Dali::DaliException e) {
18029       {
18030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18031       };
18032     } catch (...) {
18033       {
18034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18035       };
18036     }
18037   }
18038
18039   jresult = result;
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18045   unsigned int jresult ;
18046   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18047   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18048   std::string *arg3 = 0 ;
18049   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18050   bool result;
18051
18052   arg1 = (Dali::BaseObject *)jarg1;
18053   arg2 = (ConnectionTrackerInterface *)jarg2;
18054   if (!jarg3) {
18055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18056     return 0;
18057   }
18058   std::string arg3_str(jarg3);
18059   arg3 = &arg3_str;
18060   arg4 = (FunctorDelegate *)jarg4;
18061   {
18062     try {
18063       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18064     } catch (std::out_of_range& e) {
18065       {
18066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18067       };
18068     } catch (std::exception& e) {
18069       {
18070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18071       };
18072     } catch (Dali::DaliException e) {
18073       {
18074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18075       };
18076     } catch (...) {
18077       {
18078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18079       };
18080     }
18081   }
18082
18083   jresult = result;
18084
18085   //argout typemap for const std::string&
18086
18087   return jresult;
18088 }
18089
18090
18091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18092   void * jresult ;
18093   Dali::BaseHandle *arg1 = 0 ;
18094   Dali::BaseObject *result = 0 ;
18095
18096   arg1 = (Dali::BaseHandle *)jarg1;
18097   if (!arg1) {
18098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18099     return 0;
18100   }
18101   {
18102     try {
18103       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18104     } catch (std::out_of_range& e) {
18105       {
18106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (std::exception& e) {
18109       {
18110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18111       };
18112     } catch (Dali::DaliException e) {
18113       {
18114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18115       };
18116     } catch (...) {
18117       {
18118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18119       };
18120     }
18121   }
18122
18123   jresult = (void *)result;
18124   return jresult;
18125 }
18126
18127
18128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18129   void * jresult ;
18130   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18131   Dali::BaseHandle *result = 0 ;
18132
18133   arg1 = (Dali::BaseObject *)jarg1;
18134   {
18135     try {
18136       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18137     } catch (std::out_of_range& e) {
18138       {
18139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18140       };
18141     } catch (std::exception& e) {
18142       {
18143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18144       };
18145     } catch (Dali::DaliException e) {
18146       {
18147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18148       };
18149     } catch (...) {
18150       {
18151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18152       };
18153     }
18154   }
18155
18156   jresult = (void *)result;
18157   return jresult;
18158 }
18159
18160
18161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18162   void * jresult ;
18163   Dali::BaseHandle *result = 0 ;
18164
18165   {
18166     try {
18167       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18168     } catch (std::out_of_range& e) {
18169       {
18170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18171       };
18172     } catch (std::exception& e) {
18173       {
18174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18175       };
18176     } catch (Dali::DaliException e) {
18177       {
18178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18179       };
18180     } catch (...) {
18181       {
18182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18183       };
18184     }
18185   }
18186
18187   jresult = (void *)result;
18188   return jresult;
18189 }
18190
18191
18192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18193   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18194
18195   arg1 = (Dali::BaseHandle *)jarg1;
18196   {
18197     try {
18198       delete arg1;
18199     } catch (std::out_of_range& e) {
18200       {
18201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18202       };
18203     } catch (std::exception& e) {
18204       {
18205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18206       };
18207     } catch (Dali::DaliException e) {
18208       {
18209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18210       };
18211     } catch (...) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18214       };
18215     }
18216   }
18217
18218 }
18219
18220
18221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18222   void * jresult ;
18223   Dali::BaseHandle *arg1 = 0 ;
18224   Dali::BaseHandle *result = 0 ;
18225
18226   arg1 = (Dali::BaseHandle *)jarg1;
18227   if (!arg1) {
18228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18229     return 0;
18230   }
18231   {
18232     try {
18233       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18234     } catch (std::out_of_range& e) {
18235       {
18236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18237       };
18238     } catch (std::exception& e) {
18239       {
18240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18241       };
18242     } catch (Dali::DaliException e) {
18243       {
18244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18245       };
18246     } catch (...) {
18247       {
18248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18249       };
18250     }
18251   }
18252
18253   jresult = (void *)result;
18254   return jresult;
18255 }
18256
18257
18258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18259   void * jresult ;
18260   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18261   Dali::BaseHandle *arg2 = 0 ;
18262   Dali::BaseHandle *result = 0 ;
18263
18264   arg1 = (Dali::BaseHandle *)jarg1;
18265   arg2 = (Dali::BaseHandle *)jarg2;
18266   if (!arg2) {
18267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18268     return 0;
18269   }
18270   {
18271     try {
18272       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18273     } catch (std::out_of_range& e) {
18274       {
18275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18276       };
18277     } catch (std::exception& e) {
18278       {
18279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (Dali::DaliException e) {
18282       {
18283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18284       };
18285     } catch (...) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18288       };
18289     }
18290   }
18291
18292   jresult = (void *)result;
18293   return jresult;
18294 }
18295
18296
18297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18298   unsigned int jresult ;
18299   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18300   std::string *arg2 = 0 ;
18301   Dali::Property::Map *arg3 = 0 ;
18302   bool result;
18303
18304   arg1 = (Dali::BaseHandle *)jarg1;
18305   if (!jarg2) {
18306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18307     return 0;
18308   }
18309   std::string arg2_str(jarg2);
18310   arg2 = &arg2_str;
18311   arg3 = (Dali::Property::Map *)jarg3;
18312   if (!arg3) {
18313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18314     return 0;
18315   }
18316   {
18317     try {
18318       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18319     } catch (std::out_of_range& e) {
18320       {
18321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18322       };
18323     } catch (std::exception& e) {
18324       {
18325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18326       };
18327     } catch (Dali::DaliException e) {
18328       {
18329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18330       };
18331     } catch (...) {
18332       {
18333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18334       };
18335     }
18336   }
18337
18338   jresult = result;
18339
18340   //argout typemap for const std::string&
18341
18342   return jresult;
18343 }
18344
18345
18346 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18347   char * jresult ;
18348   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18349   std::string *result = 0 ;
18350
18351   arg1 = (Dali::BaseHandle *)jarg1;
18352   {
18353     try {
18354       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18355     } catch (std::out_of_range& e) {
18356       {
18357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18358       };
18359     } catch (std::exception& e) {
18360       {
18361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18362       };
18363     } catch (Dali::DaliException e) {
18364       {
18365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18366       };
18367     } catch (...) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18370       };
18371     }
18372   }
18373
18374   jresult = SWIG_csharp_string_callback(result->c_str());
18375   return jresult;
18376 }
18377
18378
18379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18380   unsigned int jresult ;
18381   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18382   Dali::TypeInfo *arg2 = 0 ;
18383   bool result;
18384
18385   arg1 = (Dali::BaseHandle *)jarg1;
18386   arg2 = (Dali::TypeInfo *)jarg2;
18387   if (!arg2) {
18388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18389     return 0;
18390   }
18391   {
18392     try {
18393       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18394     } catch (std::out_of_range& e) {
18395       {
18396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18397       };
18398     } catch (std::exception& e) {
18399       {
18400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18401       };
18402     } catch (Dali::DaliException e) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18405       };
18406     } catch (...) {
18407       {
18408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18409       };
18410     }
18411   }
18412
18413   jresult = result;
18414   return jresult;
18415 }
18416
18417
18418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18419   void * jresult ;
18420   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18421   Dali::BaseObject *result = 0 ;
18422
18423   arg1 = (Dali::BaseHandle *)jarg1;
18424   {
18425     try {
18426       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18427     } catch (std::out_of_range& e) {
18428       {
18429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18430       };
18431     } catch (std::exception& e) {
18432       {
18433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (Dali::DaliException e) {
18436       {
18437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18438       };
18439     } catch (...) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18442       };
18443     }
18444   }
18445
18446   jresult = (void *)result;
18447   return jresult;
18448 }
18449
18450
18451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18452   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18453
18454   arg1 = (Dali::BaseHandle *)jarg1;
18455   {
18456     try {
18457       (arg1)->Reset();
18458     } catch (std::out_of_range& e) {
18459       {
18460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18461       };
18462     } catch (std::exception& e) {
18463       {
18464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18465       };
18466     } catch (Dali::DaliException e) {
18467       {
18468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18469       };
18470     } catch (...) {
18471       {
18472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18473       };
18474     }
18475   }
18476
18477 }
18478
18479
18480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18481   unsigned int jresult ;
18482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18483   Dali::BaseHandle *arg2 = 0 ;
18484   bool result;
18485
18486   arg1 = (Dali::BaseHandle *)jarg1;
18487   arg2 = (Dali::BaseHandle *)jarg2;
18488   if (!arg2) {
18489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18490     return 0;
18491   }
18492   {
18493     try {
18494       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18502       };
18503     } catch (Dali::DaliException e) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18506       };
18507     } catch (...) {
18508       {
18509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18510       };
18511     }
18512   }
18513
18514   jresult = result;
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18520   unsigned int jresult ;
18521   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18522   Dali::BaseHandle *arg2 = 0 ;
18523   bool result;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   arg2 = (Dali::BaseHandle *)jarg2;
18527   if (!arg2) {
18528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18529     return 0;
18530   }
18531   {
18532     try {
18533       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (Dali::DaliException e) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18545       };
18546     } catch (...) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18549       };
18550     }
18551   }
18552
18553   jresult = result;
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18559   void * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   Dali::RefObject *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = (void *)result;
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18592   unsigned int jresult ;
18593   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18594   bool result;
18595
18596   arg1 = (Dali::BaseHandle *)jarg1;
18597   {
18598     try {
18599       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18600     } catch (std::out_of_range& e) {
18601       {
18602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18603       };
18604     } catch (std::exception& e) {
18605       {
18606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18607       };
18608     } catch (Dali::DaliException e) {
18609       {
18610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18611       };
18612     } catch (...) {
18613       {
18614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18615       };
18616     }
18617   }
18618
18619   jresult = result;
18620   return jresult;
18621 }
18622
18623
18624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18625   unsigned int jresult ;
18626   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18627   Dali::BaseHandle *arg2 = 0 ;
18628   bool result;
18629
18630   arg1 = (Dali::BaseHandle *)jarg1;
18631   arg2 = (Dali::BaseHandle *)jarg2;
18632   if (!arg2) {
18633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18634     return 0;
18635   }
18636   {
18637     try {
18638       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18639     } catch (std::out_of_range& e) {
18640       {
18641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (std::exception& e) {
18644       {
18645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18646       };
18647     } catch (Dali::DaliException e) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18654       };
18655     }
18656   }
18657
18658   jresult = result;
18659   return jresult;
18660 }
18661
18662
18663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18664   unsigned int jresult ;
18665   Dali::BaseHandle *arg1 = 0 ;
18666   Dali::BaseHandle *arg2 = 0 ;
18667   bool result;
18668
18669   arg1 = (Dali::BaseHandle *)jarg1;
18670   if (!arg1) {
18671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18672     return 0;
18673   }
18674   arg2 = (Dali::BaseHandle *)jarg2;
18675   if (!arg2) {
18676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18677     return 0;
18678   }
18679   {
18680     try {
18681       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18682     } catch (std::out_of_range& e) {
18683       {
18684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18685       };
18686     } catch (std::exception& e) {
18687       {
18688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18689       };
18690     } catch (Dali::DaliException e) {
18691       {
18692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18693       };
18694     } catch (...) {
18695       {
18696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18697       };
18698     }
18699   }
18700
18701   jresult = result;
18702   return jresult;
18703 }
18704
18705
18706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18707   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18708
18709   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18710   {
18711     try {
18712       delete arg1;
18713     } catch (std::out_of_range& e) {
18714       {
18715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18716       };
18717     } catch (std::exception& e) {
18718       {
18719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18720       };
18721     } catch (Dali::DaliException e) {
18722       {
18723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18724       };
18725     } catch (...) {
18726       {
18727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18728       };
18729     }
18730   }
18731
18732 }
18733
18734
18735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18736   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18737   SlotObserver *arg2 = (SlotObserver *) 0 ;
18738   CallbackBase *arg3 = (CallbackBase *) 0 ;
18739
18740   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18741   arg2 = (SlotObserver *)jarg2;
18742   arg3 = (CallbackBase *)jarg3;
18743   {
18744     try {
18745       (arg1)->SignalConnected(arg2,arg3);
18746     } catch (std::out_of_range& e) {
18747       {
18748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18749       };
18750     } catch (std::exception& e) {
18751       {
18752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18753       };
18754     } catch (Dali::DaliException e) {
18755       {
18756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18757       };
18758     } catch (...) {
18759       {
18760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18761       };
18762     }
18763   }
18764
18765 }
18766
18767
18768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18769   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18770
18771   arg1 = (Dali::SignalObserver *)jarg1;
18772   {
18773     try {
18774       delete arg1;
18775     } catch (std::out_of_range& e) {
18776       {
18777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18778       };
18779     } catch (std::exception& e) {
18780       {
18781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18782       };
18783     } catch (Dali::DaliException e) {
18784       {
18785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18786       };
18787     } catch (...) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18790       };
18791     }
18792   }
18793
18794 }
18795
18796
18797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18798   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18799   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18800   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18801
18802   arg1 = (Dali::SignalObserver *)jarg1;
18803   arg2 = (Dali::SlotObserver *)jarg2;
18804   arg3 = (Dali::CallbackBase *)jarg3;
18805   {
18806     try {
18807       (arg1)->SignalDisconnected(arg2,arg3);
18808     } catch (std::out_of_range& e) {
18809       {
18810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18811       };
18812     } catch (std::exception& e) {
18813       {
18814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18815       };
18816     } catch (Dali::DaliException e) {
18817       {
18818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18819       };
18820     } catch (...) {
18821       {
18822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18823       };
18824     }
18825   }
18826
18827 }
18828
18829
18830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18831   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18832
18833   arg1 = (Dali::SlotObserver *)jarg1;
18834   {
18835     try {
18836       delete arg1;
18837     } catch (std::out_of_range& e) {
18838       {
18839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18840       };
18841     } catch (std::exception& e) {
18842       {
18843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18844       };
18845     } catch (Dali::DaliException e) {
18846       {
18847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18848       };
18849     } catch (...) {
18850       {
18851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18852       };
18853     }
18854   }
18855
18856 }
18857
18858
18859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18860   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18861   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18862
18863   arg1 = (Dali::SlotObserver *)jarg1;
18864   arg2 = (Dali::CallbackBase *)jarg2;
18865   {
18866     try {
18867       (arg1)->SlotDisconnected(arg2);
18868     } catch (std::out_of_range& e) {
18869       {
18870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18871       };
18872     } catch (std::exception& e) {
18873       {
18874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18875       };
18876     } catch (Dali::DaliException e) {
18877       {
18878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18879       };
18880     } catch (...) {
18881       {
18882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18883       };
18884     }
18885   }
18886
18887 }
18888
18889
18890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
18891   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18892
18893   arg1 = (Dali::ConnectionTracker *)jarg1;
18894   {
18895     try {
18896       delete arg1;
18897     } catch (std::out_of_range& e) {
18898       {
18899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18900       };
18901     } catch (std::exception& e) {
18902       {
18903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18904       };
18905     } catch (Dali::DaliException e) {
18906       {
18907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18908       };
18909     } catch (...) {
18910       {
18911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18912       };
18913     }
18914   }
18915
18916 }
18917
18918
18919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
18920   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18921
18922   arg1 = (Dali::ConnectionTracker *)jarg1;
18923   {
18924     try {
18925       (arg1)->DisconnectAll();
18926     } catch (std::out_of_range& e) {
18927       {
18928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18929       };
18930     } catch (std::exception& e) {
18931       {
18932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18933       };
18934     } catch (Dali::DaliException e) {
18935       {
18936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18937       };
18938     } catch (...) {
18939       {
18940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18941       };
18942     }
18943   }
18944
18945 }
18946
18947
18948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18949   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18950   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18951   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18952
18953   arg1 = (Dali::ConnectionTracker *)jarg1;
18954   arg2 = (Dali::SlotObserver *)jarg2;
18955   arg3 = (Dali::CallbackBase *)jarg3;
18956   {
18957     try {
18958       (arg1)->SignalConnected(arg2,arg3);
18959     } catch (std::out_of_range& e) {
18960       {
18961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18962       };
18963     } catch (std::exception& e) {
18964       {
18965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18966       };
18967     } catch (Dali::DaliException e) {
18968       {
18969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18970       };
18971     } catch (...) {
18972       {
18973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18974       };
18975     }
18976   }
18977
18978 }
18979
18980
18981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18982   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
18983   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18984   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18985
18986   arg1 = (Dali::ConnectionTracker *)jarg1;
18987   arg2 = (Dali::SlotObserver *)jarg2;
18988   arg3 = (Dali::CallbackBase *)jarg3;
18989   {
18990     try {
18991       (arg1)->SignalDisconnected(arg2,arg3);
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18999       };
19000     } catch (Dali::DaliException e) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19003       };
19004     } catch (...) {
19005       {
19006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19007       };
19008     }
19009   }
19010
19011 }
19012
19013
19014 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19015   unsigned long jresult ;
19016   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19017   std::size_t result;
19018
19019   arg1 = (Dali::ConnectionTracker *)jarg1;
19020   {
19021     try {
19022       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19023     } catch (std::out_of_range& e) {
19024       {
19025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19026       };
19027     } catch (std::exception& e) {
19028       {
19029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19030       };
19031     } catch (Dali::DaliException e) {
19032       {
19033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19034       };
19035     } catch (...) {
19036       {
19037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19038       };
19039     }
19040   }
19041
19042   jresult = (unsigned long)result;
19043   return jresult;
19044 }
19045
19046
19047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19048   void * jresult ;
19049   Dali::ObjectRegistry *result = 0 ;
19050
19051   {
19052     try {
19053       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19054     } catch (std::out_of_range& e) {
19055       {
19056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19057       };
19058     } catch (std::exception& e) {
19059       {
19060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19061       };
19062     } catch (Dali::DaliException e) {
19063       {
19064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19065       };
19066     } catch (...) {
19067       {
19068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19069       };
19070     }
19071   }
19072
19073   jresult = (void *)result;
19074   return jresult;
19075 }
19076
19077
19078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19079   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19080
19081   arg1 = (Dali::ObjectRegistry *)jarg1;
19082   {
19083     try {
19084       delete arg1;
19085     } catch (std::out_of_range& e) {
19086       {
19087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19088       };
19089     } catch (std::exception& e) {
19090       {
19091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19092       };
19093     } catch (Dali::DaliException e) {
19094       {
19095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19096       };
19097     } catch (...) {
19098       {
19099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19100       };
19101     }
19102   }
19103
19104 }
19105
19106
19107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19108   void * jresult ;
19109   Dali::ObjectRegistry *arg1 = 0 ;
19110   Dali::ObjectRegistry *result = 0 ;
19111
19112   arg1 = (Dali::ObjectRegistry *)jarg1;
19113   if (!arg1) {
19114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19115     return 0;
19116   }
19117   {
19118     try {
19119       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19120     } catch (std::out_of_range& e) {
19121       {
19122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19123       };
19124     } catch (std::exception& e) {
19125       {
19126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19127       };
19128     } catch (Dali::DaliException e) {
19129       {
19130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19131       };
19132     } catch (...) {
19133       {
19134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19135       };
19136     }
19137   }
19138
19139   jresult = (void *)result;
19140   return jresult;
19141 }
19142
19143
19144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19145   void * jresult ;
19146   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19147   Dali::ObjectRegistry *arg2 = 0 ;
19148   Dali::ObjectRegistry *result = 0 ;
19149
19150   arg1 = (Dali::ObjectRegistry *)jarg1;
19151   arg2 = (Dali::ObjectRegistry *)jarg2;
19152   if (!arg2) {
19153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19154     return 0;
19155   }
19156   {
19157     try {
19158       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19159     } catch (std::out_of_range& e) {
19160       {
19161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (std::exception& e) {
19164       {
19165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (Dali::DaliException e) {
19168       {
19169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19170       };
19171     } catch (...) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19174       };
19175     }
19176   }
19177
19178   jresult = (void *)result;
19179   return jresult;
19180 }
19181
19182
19183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19184   void * jresult ;
19185   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19186   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19187
19188   arg1 = (Dali::ObjectRegistry *)jarg1;
19189   {
19190     try {
19191       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (Dali::DaliException e) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19203       };
19204     } catch (...) {
19205       {
19206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19207       };
19208     }
19209   }
19210
19211   jresult = (void *)result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19217   void * jresult ;
19218   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19219   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19220
19221   arg1 = (Dali::ObjectRegistry *)jarg1;
19222   {
19223     try {
19224       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243
19244   jresult = (void *)result;
19245   return jresult;
19246 }
19247
19248
19249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19250   void * jresult ;
19251   Dali::PropertyCondition *result = 0 ;
19252
19253   {
19254     try {
19255       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19256     } catch (std::out_of_range& e) {
19257       {
19258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (std::exception& e) {
19261       {
19262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (Dali::DaliException e) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19267       };
19268     } catch (...) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19271       };
19272     }
19273   }
19274
19275   jresult = (void *)result;
19276   return jresult;
19277 }
19278
19279
19280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19281   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19282
19283   arg1 = (Dali::PropertyCondition *)jarg1;
19284   {
19285     try {
19286       delete arg1;
19287     } catch (std::out_of_range& e) {
19288       {
19289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19290       };
19291     } catch (std::exception& e) {
19292       {
19293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19294       };
19295     } catch (Dali::DaliException e) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19298       };
19299     } catch (...) {
19300       {
19301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19302       };
19303     }
19304   }
19305
19306 }
19307
19308
19309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19310   void * jresult ;
19311   Dali::PropertyCondition *arg1 = 0 ;
19312   Dali::PropertyCondition *result = 0 ;
19313
19314   arg1 = (Dali::PropertyCondition *)jarg1;
19315   if (!arg1) {
19316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19317     return 0;
19318   }
19319   {
19320     try {
19321       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19322     } catch (std::out_of_range& e) {
19323       {
19324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19325       };
19326     } catch (std::exception& e) {
19327       {
19328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19329       };
19330     } catch (Dali::DaliException e) {
19331       {
19332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19333       };
19334     } catch (...) {
19335       {
19336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19337       };
19338     }
19339   }
19340
19341   jresult = (void *)result;
19342   return jresult;
19343 }
19344
19345
19346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19347   void * jresult ;
19348   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19349   Dali::PropertyCondition *arg2 = 0 ;
19350   Dali::PropertyCondition *result = 0 ;
19351
19352   arg1 = (Dali::PropertyCondition *)jarg1;
19353   arg2 = (Dali::PropertyCondition *)jarg2;
19354   if (!arg2) {
19355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19356     return 0;
19357   }
19358   {
19359     try {
19360       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19361     } catch (std::out_of_range& e) {
19362       {
19363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19364       };
19365     } catch (std::exception& e) {
19366       {
19367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (Dali::DaliException e) {
19370       {
19371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19372       };
19373     } catch (...) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19376       };
19377     }
19378   }
19379
19380   jresult = (void *)result;
19381   return jresult;
19382 }
19383
19384
19385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19386   unsigned long jresult ;
19387   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19388   std::size_t result;
19389
19390   arg1 = (Dali::PropertyCondition *)jarg1;
19391   {
19392     try {
19393       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (...) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19405       };
19406     }
19407   }
19408   jresult = (unsigned long)result;
19409   return jresult;
19410 }
19411
19412
19413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19414   float jresult ;
19415   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19416   std::size_t arg2 ;
19417   float result;
19418
19419   arg1 = (Dali::PropertyCondition *)jarg1;
19420   arg2 = (std::size_t)jarg2;
19421   {
19422     try {
19423       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19424     } catch (std::out_of_range& e) {
19425       {
19426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19427       };
19428     } catch (std::exception& e) {
19429       {
19430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19431       };
19432     } catch (...) {
19433       {
19434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19435       };
19436     }
19437   }
19438   jresult = result;
19439   return jresult;
19440 }
19441
19442
19443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19444   void * jresult ;
19445   float arg1 ;
19446   Dali::PropertyCondition result;
19447
19448   arg1 = (float)jarg1;
19449   {
19450     try {
19451       result = Dali::LessThanCondition(arg1);
19452     } catch (std::out_of_range& e) {
19453       {
19454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19455       };
19456     } catch (std::exception& e) {
19457       {
19458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19459       };
19460     } catch (Dali::DaliException e) {
19461       {
19462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19463       };
19464     } catch (...) {
19465       {
19466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19467       };
19468     }
19469   }
19470
19471   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19472   return jresult;
19473 }
19474
19475
19476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19477   void * jresult ;
19478   float arg1 ;
19479   Dali::PropertyCondition result;
19480
19481   arg1 = (float)jarg1;
19482   {
19483     try {
19484       result = Dali::GreaterThanCondition(arg1);
19485     } catch (std::out_of_range& e) {
19486       {
19487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19488       };
19489     } catch (std::exception& e) {
19490       {
19491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19492       };
19493     } catch (Dali::DaliException e) {
19494       {
19495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19496       };
19497     } catch (...) {
19498       {
19499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19500       };
19501     }
19502   }
19503
19504   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19505   return jresult;
19506 }
19507
19508
19509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19510   void * jresult ;
19511   float arg1 ;
19512   float arg2 ;
19513   Dali::PropertyCondition result;
19514
19515   arg1 = (float)jarg1;
19516   arg2 = (float)jarg2;
19517   {
19518     try {
19519       result = Dali::InsideCondition(arg1,arg2);
19520     } catch (std::out_of_range& e) {
19521       {
19522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19523       };
19524     } catch (std::exception& e) {
19525       {
19526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19527       };
19528     } catch (Dali::DaliException e) {
19529       {
19530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19531       };
19532     } catch (...) {
19533       {
19534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19535       };
19536     }
19537   }
19538
19539   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19540   return jresult;
19541 }
19542
19543
19544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19545   void * jresult ;
19546   float arg1 ;
19547   float arg2 ;
19548   Dali::PropertyCondition result;
19549
19550   arg1 = (float)jarg1;
19551   arg2 = (float)jarg2;
19552   {
19553     try {
19554       result = Dali::OutsideCondition(arg1,arg2);
19555     } catch (std::out_of_range& e) {
19556       {
19557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19558       };
19559     } catch (std::exception& e) {
19560       {
19561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19562       };
19563     } catch (Dali::DaliException e) {
19564       {
19565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19570       };
19571     }
19572   }
19573
19574   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19575   return jresult;
19576 }
19577
19578
19579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19580   void * jresult ;
19581   float arg1 ;
19582   float arg2 ;
19583   Dali::PropertyCondition result;
19584
19585   arg1 = (float)jarg1;
19586   arg2 = (float)jarg2;
19587   {
19588     try {
19589       result = Dali::StepCondition(arg1,arg2);
19590     } catch (std::out_of_range& e) {
19591       {
19592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (std::exception& e) {
19595       {
19596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (Dali::DaliException e) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608
19609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19610   return jresult;
19611 }
19612
19613
19614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19615   void * jresult ;
19616   float arg1 ;
19617   Dali::PropertyCondition result;
19618
19619   arg1 = (float)jarg1;
19620   {
19621     try {
19622       result = Dali::StepCondition(arg1);
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19630       };
19631     } catch (Dali::DaliException e) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19638       };
19639     }
19640   }
19641
19642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19643   return jresult;
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19648   void * jresult ;
19649   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19650   Dali::PropertyCondition result;
19651
19652   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19653   if (!arg1) {
19654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19655     return 0;
19656   }
19657   {
19658     try {
19659       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19675       };
19676     }
19677   }
19678
19679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19685   void * jresult ;
19686   Dali::PropertyNotification *result = 0 ;
19687
19688   {
19689     try {
19690       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19691     } catch (std::out_of_range& e) {
19692       {
19693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19694       };
19695     } catch (std::exception& e) {
19696       {
19697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (Dali::DaliException e) {
19700       {
19701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19702       };
19703     } catch (...) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19706       };
19707     }
19708   }
19709
19710   jresult = (void *)result;
19711   return jresult;
19712 }
19713
19714
19715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19716   void * jresult ;
19717   Dali::BaseHandle arg1 ;
19718   Dali::BaseHandle *argp1 ;
19719   Dali::PropertyNotification result;
19720
19721   argp1 = (Dali::BaseHandle *)jarg1;
19722   if (!argp1) {
19723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19724     return 0;
19725   }
19726   arg1 = *argp1;
19727   {
19728     try {
19729       result = Dali::PropertyNotification::DownCast(arg1);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19755   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19756
19757   arg1 = (Dali::PropertyNotification *)jarg1;
19758   {
19759     try {
19760       delete arg1;
19761     } catch (std::out_of_range& e) {
19762       {
19763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19764       };
19765     } catch (std::exception& e) {
19766       {
19767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19768       };
19769     } catch (Dali::DaliException e) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19776       };
19777     }
19778   }
19779
19780 }
19781
19782
19783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19784   void * jresult ;
19785   Dali::PropertyNotification *arg1 = 0 ;
19786   Dali::PropertyNotification *result = 0 ;
19787
19788   arg1 = (Dali::PropertyNotification *)jarg1;
19789   if (!arg1) {
19790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19791     return 0;
19792   }
19793   {
19794     try {
19795       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19796     } catch (std::out_of_range& e) {
19797       {
19798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (std::exception& e) {
19801       {
19802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (Dali::DaliException e) {
19805       {
19806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19807       };
19808     } catch (...) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19811       };
19812     }
19813   }
19814
19815   jresult = (void *)result;
19816   return jresult;
19817 }
19818
19819
19820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19821   void * jresult ;
19822   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19823   Dali::PropertyNotification *arg2 = 0 ;
19824   Dali::PropertyNotification *result = 0 ;
19825
19826   arg1 = (Dali::PropertyNotification *)jarg1;
19827   arg2 = (Dali::PropertyNotification *)jarg2;
19828   if (!arg2) {
19829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19830     return 0;
19831   }
19832   {
19833     try {
19834       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19835     } catch (std::out_of_range& e) {
19836       {
19837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (std::exception& e) {
19840       {
19841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19842       };
19843     } catch (Dali::DaliException e) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19846       };
19847     } catch (...) {
19848       {
19849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19850       };
19851     }
19852   }
19853
19854   jresult = (void *)result;
19855   return jresult;
19856 }
19857
19858
19859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19860   void * jresult ;
19861   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19862   Dali::PropertyCondition result;
19863
19864   arg1 = (Dali::PropertyNotification *)jarg1;
19865   {
19866     try {
19867       result = (arg1)->GetCondition();
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19883       };
19884     }
19885   }
19886
19887   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
19893   void * jresult ;
19894   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19895   Dali::Handle result;
19896
19897   arg1 = (Dali::PropertyNotification *)jarg1;
19898   {
19899     try {
19900       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19916       };
19917     }
19918   }
19919
19920   jresult = new Dali::Handle((const Dali::Handle &)result);
19921   return jresult;
19922 }
19923
19924
19925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
19926   int jresult ;
19927   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19928   Dali::Property::Index result;
19929
19930   arg1 = (Dali::PropertyNotification *)jarg1;
19931   {
19932     try {
19933       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
19959   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19960   Dali::PropertyNotification::NotifyMode arg2 ;
19961
19962   arg1 = (Dali::PropertyNotification *)jarg1;
19963   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
19964   {
19965     try {
19966       (arg1)->SetNotifyMode(arg2);
19967     } catch (std::out_of_range& e) {
19968       {
19969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19970       };
19971     } catch (std::exception& e) {
19972       {
19973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19974       };
19975     } catch (Dali::DaliException e) {
19976       {
19977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19978       };
19979     } catch (...) {
19980       {
19981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19982       };
19983     }
19984   }
19985
19986 }
19987
19988
19989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
19990   int jresult ;
19991   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19992   Dali::PropertyNotification::NotifyMode result;
19993
19994   arg1 = (Dali::PropertyNotification *)jarg1;
19995   {
19996     try {
19997       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
19998     } catch (std::out_of_range& e) {
19999       {
20000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20001       };
20002     } catch (std::exception& e) {
20003       {
20004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (Dali::DaliException e) {
20007       {
20008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20009       };
20010     } catch (...) {
20011       {
20012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20013       };
20014     }
20015   }
20016
20017   jresult = (int)result;
20018   return jresult;
20019 }
20020
20021
20022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20023   unsigned int jresult ;
20024   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20025   bool result;
20026
20027   arg1 = (Dali::PropertyNotification *)jarg1;
20028   {
20029     try {
20030       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20031     } catch (std::out_of_range& e) {
20032       {
20033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20034       };
20035     } catch (std::exception& e) {
20036       {
20037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20038       };
20039     } catch (Dali::DaliException e) {
20040       {
20041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20042       };
20043     } catch (...) {
20044       {
20045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20046       };
20047     }
20048   }
20049
20050   jresult = result;
20051   return jresult;
20052 }
20053
20054
20055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20056   void * jresult ;
20057   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20058   Dali::PropertyNotifySignalType *result = 0 ;
20059
20060   arg1 = (Dali::PropertyNotification *)jarg1;
20061   {
20062     try {
20063       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20064     } catch (std::out_of_range& e) {
20065       {
20066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20067       };
20068     } catch (std::exception& e) {
20069       {
20070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20071       };
20072     } catch (Dali::DaliException e) {
20073       {
20074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20075       };
20076     } catch (...) {
20077       {
20078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20079       };
20080     }
20081   }
20082
20083   jresult = (void *)result;
20084   return jresult;
20085 }
20086
20087
20088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20089   void * jresult ;
20090   Dali::Handle *result = 0 ;
20091
20092   {
20093     try {
20094       result = (Dali::Handle *)new Dali::Handle();
20095     } catch (std::out_of_range& e) {
20096       {
20097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20098       };
20099     } catch (std::exception& e) {
20100       {
20101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20102       };
20103     } catch (Dali::DaliException e) {
20104       {
20105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20106       };
20107     } catch (...) {
20108       {
20109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20110       };
20111     }
20112   }
20113
20114   jresult = (void *)result;
20115   return jresult;
20116 }
20117
20118
20119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20120   void * jresult ;
20121   Dali::Handle result;
20122
20123   {
20124     try {
20125       result = Dali::Handle::New();
20126     } catch (std::out_of_range& e) {
20127       {
20128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20129       };
20130     } catch (std::exception& e) {
20131       {
20132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20133       };
20134     } catch (Dali::DaliException e) {
20135       {
20136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20137       };
20138     } catch (...) {
20139       {
20140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20141       };
20142     }
20143   }
20144
20145   jresult = new Dali::Handle((const Dali::Handle &)result);
20146   return jresult;
20147 }
20148
20149
20150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20152
20153   arg1 = (Dali::Handle *)jarg1;
20154   {
20155     try {
20156       delete arg1;
20157     } catch (std::out_of_range& e) {
20158       {
20159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20160       };
20161     } catch (std::exception& e) {
20162       {
20163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20164       };
20165     } catch (Dali::DaliException e) {
20166       {
20167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20168       };
20169     } catch (...) {
20170       {
20171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20172       };
20173     }
20174   }
20175
20176 }
20177
20178
20179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20180   void * jresult ;
20181   Dali::Handle *arg1 = 0 ;
20182   Dali::Handle *result = 0 ;
20183
20184   arg1 = (Dali::Handle *)jarg1;
20185   if (!arg1) {
20186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20187     return 0;
20188   }
20189   {
20190     try {
20191       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20192     } catch (std::out_of_range& e) {
20193       {
20194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20195       };
20196     } catch (std::exception& e) {
20197       {
20198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20199       };
20200     } catch (Dali::DaliException e) {
20201       {
20202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20203       };
20204     } catch (...) {
20205       {
20206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20207       };
20208     }
20209   }
20210
20211   jresult = (void *)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20217   void * jresult ;
20218   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20219   Dali::Handle *arg2 = 0 ;
20220   Dali::Handle *result = 0 ;
20221
20222   arg1 = (Dali::Handle *)jarg1;
20223   arg2 = (Dali::Handle *)jarg2;
20224   if (!arg2) {
20225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20226     return 0;
20227   }
20228   {
20229     try {
20230       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20231     } catch (std::out_of_range& e) {
20232       {
20233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20234       };
20235     } catch (std::exception& e) {
20236       {
20237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (Dali::DaliException e) {
20240       {
20241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20242       };
20243     } catch (...) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20246       };
20247     }
20248   }
20249
20250   jresult = (void *)result;
20251   return jresult;
20252 }
20253
20254
20255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20256   void * jresult ;
20257   Dali::BaseHandle arg1 ;
20258   Dali::BaseHandle *argp1 ;
20259   Dali::Handle result;
20260
20261   argp1 = (Dali::BaseHandle *)jarg1;
20262   if (!argp1) {
20263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20264     return 0;
20265   }
20266   arg1 = *argp1;
20267   {
20268     try {
20269       result = Dali::Handle::DownCast(arg1);
20270     } catch (std::out_of_range& e) {
20271       {
20272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20273       };
20274     } catch (std::exception& e) {
20275       {
20276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20277       };
20278     } catch (Dali::DaliException e) {
20279       {
20280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20281       };
20282     } catch (...) {
20283       {
20284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20285       };
20286     }
20287   }
20288
20289   jresult = new Dali::Handle((const Dali::Handle &)result);
20290   return jresult;
20291 }
20292
20293
20294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20295   unsigned int jresult ;
20296   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20297   Dali::Handle::Capability arg2 ;
20298   bool result;
20299
20300   arg1 = (Dali::Handle *)jarg1;
20301   arg2 = (Dali::Handle::Capability)jarg2;
20302   {
20303     try {
20304       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20305     } catch (std::out_of_range& e) {
20306       {
20307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20308       };
20309     } catch (std::exception& e) {
20310       {
20311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20312       };
20313     } catch (Dali::DaliException e) {
20314       {
20315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20316       };
20317     } catch (...) {
20318       {
20319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20320       };
20321     }
20322   }
20323
20324   jresult = result;
20325   return jresult;
20326 }
20327
20328
20329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20330   unsigned int jresult ;
20331   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20332   unsigned int result;
20333
20334   arg1 = (Dali::Handle *)jarg1;
20335   {
20336     try {
20337       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20338     } catch (std::out_of_range& e) {
20339       {
20340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20341       };
20342     } catch (std::exception& e) {
20343       {
20344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20345       };
20346     } catch (Dali::DaliException e) {
20347       {
20348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20349       };
20350     } catch (...) {
20351       {
20352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20353       };
20354     }
20355   }
20356
20357   jresult = result;
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20363   char * jresult ;
20364   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20365   Dali::Property::Index arg2 ;
20366   std::string result;
20367
20368   arg1 = (Dali::Handle *)jarg1;
20369   arg2 = (Dali::Property::Index)jarg2;
20370   {
20371     try {
20372       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20373     } catch (std::out_of_range& e) {
20374       {
20375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20376       };
20377     } catch (std::exception& e) {
20378       {
20379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20380       };
20381     } catch (Dali::DaliException e) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20384       };
20385     } catch (...) {
20386       {
20387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20388       };
20389     }
20390   }
20391
20392   jresult = SWIG_csharp_string_callback((&result)->c_str());
20393   return jresult;
20394 }
20395
20396
20397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20398   int jresult ;
20399   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20400   std::string *arg2 = 0 ;
20401   Dali::Property::Index result;
20402
20403   arg1 = (Dali::Handle *)jarg1;
20404   if (!jarg2) {
20405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20406     return 0;
20407   }
20408   std::string arg2_str(jarg2);
20409   arg2 = &arg2_str;
20410   {
20411     try {
20412       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20413     } catch (std::out_of_range& e) {
20414       {
20415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20416       };
20417     } catch (std::exception& e) {
20418       {
20419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20420       };
20421     } catch (Dali::DaliException e) {
20422       {
20423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20424       };
20425     } catch (...) {
20426       {
20427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20428       };
20429     }
20430   }
20431
20432   jresult = result;
20433
20434   //argout typemap for const std::string&
20435
20436   return jresult;
20437 }
20438
20439
20440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20441   unsigned int jresult ;
20442   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20443   Dali::Property::Index arg2 ;
20444   bool result;
20445
20446   arg1 = (Dali::Handle *)jarg1;
20447   arg2 = (Dali::Property::Index)jarg2;
20448   {
20449     try {
20450       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20451     } catch (std::out_of_range& e) {
20452       {
20453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20454       };
20455     } catch (std::exception& e) {
20456       {
20457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20458       };
20459     } catch (Dali::DaliException e) {
20460       {
20461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20462       };
20463     } catch (...) {
20464       {
20465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20466       };
20467     }
20468   }
20469
20470   jresult = result;
20471   return jresult;
20472 }
20473
20474
20475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20476   unsigned int jresult ;
20477   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20478   Dali::Property::Index arg2 ;
20479   bool result;
20480
20481   arg1 = (Dali::Handle *)jarg1;
20482   arg2 = (Dali::Property::Index)jarg2;
20483   {
20484     try {
20485       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20486     } catch (std::out_of_range& e) {
20487       {
20488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20489       };
20490     } catch (std::exception& e) {
20491       {
20492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20493       };
20494     } catch (Dali::DaliException e) {
20495       {
20496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20497       };
20498     } catch (...) {
20499       {
20500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20501       };
20502     }
20503   }
20504
20505   jresult = result;
20506   return jresult;
20507 }
20508
20509
20510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20511   unsigned int jresult ;
20512   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20513   Dali::Property::Index arg2 ;
20514   bool result;
20515
20516   arg1 = (Dali::Handle *)jarg1;
20517   arg2 = (Dali::Property::Index)jarg2;
20518   {
20519     try {
20520       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
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 int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20546   int jresult ;
20547   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20548   Dali::Property::Index arg2 ;
20549   Dali::Property::Type result;
20550
20551   arg1 = (Dali::Handle *)jarg1;
20552   arg2 = (Dali::Property::Index)jarg2;
20553   {
20554     try {
20555       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(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 = (int)result;
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20581   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20582   Dali::Property::Index arg2 ;
20583   Dali::Property::Value *arg3 = 0 ;
20584
20585   arg1 = (Dali::Handle *)jarg1;
20586   arg2 = (Dali::Property::Index)jarg2;
20587   arg3 = (Dali::Property::Value *)jarg3;
20588   if (!arg3) {
20589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20590     return ;
20591   }
20592   {
20593     try {
20594       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20595     } catch (std::out_of_range& e) {
20596       {
20597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20598       };
20599     } catch (std::exception& e) {
20600       {
20601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20602       };
20603     } catch (Dali::DaliException e) {
20604       {
20605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20606       };
20607     } catch (...) {
20608       {
20609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20610       };
20611     }
20612   }
20613
20614 }
20615
20616
20617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20618   int jresult ;
20619   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20620   std::string *arg2 = 0 ;
20621   Dali::Property::Value *arg3 = 0 ;
20622   Dali::Property::Index result;
20623
20624   arg1 = (Dali::Handle *)jarg1;
20625   if (!jarg2) {
20626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20627     return 0;
20628   }
20629   std::string arg2_str(jarg2);
20630   arg2 = &arg2_str;
20631   arg3 = (Dali::Property::Value *)jarg3;
20632   if (!arg3) {
20633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20634     return 0;
20635   }
20636   {
20637     try {
20638       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20639     } catch (std::out_of_range& e) {
20640       {
20641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20642       };
20643     } catch (std::exception& e) {
20644       {
20645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20646       };
20647     } catch (Dali::DaliException e) {
20648       {
20649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20650       };
20651     } catch (...) {
20652       {
20653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20654       };
20655     }
20656   }
20657
20658   jresult = result;
20659
20660   //argout typemap for const std::string&
20661
20662   return jresult;
20663 }
20664
20665
20666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20667   int jresult ;
20668   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20669   std::string *arg2 = 0 ;
20670   Dali::Property::Value *arg3 = 0 ;
20671   Dali::Property::AccessMode arg4 ;
20672   Dali::Property::Index result;
20673
20674   arg1 = (Dali::Handle *)jarg1;
20675   if (!jarg2) {
20676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20677     return 0;
20678   }
20679   std::string arg2_str(jarg2);
20680   arg2 = &arg2_str;
20681   arg3 = (Dali::Property::Value *)jarg3;
20682   if (!arg3) {
20683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20684     return 0;
20685   }
20686   arg4 = (Dali::Property::AccessMode)jarg4;
20687   {
20688     try {
20689       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20690     } catch (std::out_of_range& e) {
20691       {
20692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20693       };
20694     } catch (std::exception& e) {
20695       {
20696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (Dali::DaliException e) {
20699       {
20700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20701       };
20702     } catch (...) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20705       };
20706     }
20707   }
20708
20709   jresult = result;
20710
20711   //argout typemap for const std::string&
20712
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20718   void * jresult ;
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   Dali::Property::Value result;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   {
20726     try {
20727       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20728     } catch (std::out_of_range& e) {
20729       {
20730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20731       };
20732     } catch (std::exception& e) {
20733       {
20734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20735       };
20736     } catch (Dali::DaliException e) {
20737       {
20738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20739       };
20740     } catch (...) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20743       };
20744     }
20745   }
20746
20747   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20748   return jresult;
20749 }
20750
20751
20752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20753   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20754   Dali::Property::IndexContainer *arg2 = 0 ;
20755
20756   arg1 = (Dali::Handle *)jarg1;
20757   arg2 = (Dali::Property::IndexContainer *)jarg2;
20758   if (!arg2) {
20759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20760     return ;
20761   }
20762   {
20763     try {
20764       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20765     } catch (std::out_of_range& e) {
20766       {
20767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20768       };
20769     } catch (std::exception& e) {
20770       {
20771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20772       };
20773     } catch (Dali::DaliException e) {
20774       {
20775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20776       };
20777     } catch (...) {
20778       {
20779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20780       };
20781     }
20782   }
20783
20784 }
20785
20786
20787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20788   void * jresult ;
20789   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20790   Dali::Property::Index arg2 ;
20791   Dali::PropertyCondition *arg3 = 0 ;
20792   Dali::PropertyNotification result;
20793
20794   arg1 = (Dali::Handle *)jarg1;
20795   arg2 = (Dali::Property::Index)jarg2;
20796   arg3 = (Dali::PropertyCondition *)jarg3;
20797   if (!arg3) {
20798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20799     return 0;
20800   }
20801   {
20802     try {
20803       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20804     } catch (std::out_of_range& e) {
20805       {
20806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20807       };
20808     } catch (std::exception& e) {
20809       {
20810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20811       };
20812     } catch (Dali::DaliException e) {
20813       {
20814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20815       };
20816     } catch (...) {
20817       {
20818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20819       };
20820     }
20821   }
20822
20823   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20824   return jresult;
20825 }
20826
20827
20828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20829   void * jresult ;
20830   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20831   Dali::Property::Index arg2 ;
20832   int arg3 ;
20833   Dali::PropertyCondition *arg4 = 0 ;
20834   Dali::PropertyNotification result;
20835
20836   arg1 = (Dali::Handle *)jarg1;
20837   arg2 = (Dali::Property::Index)jarg2;
20838   arg3 = (int)jarg3;
20839   arg4 = (Dali::PropertyCondition *)jarg4;
20840   if (!arg4) {
20841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20842     return 0;
20843   }
20844   {
20845     try {
20846       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20847     } catch (std::out_of_range& e) {
20848       {
20849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20850       };
20851     } catch (std::exception& e) {
20852       {
20853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (Dali::DaliException e) {
20856       {
20857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20858       };
20859     } catch (...) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20862       };
20863     }
20864   }
20865
20866   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20867   return jresult;
20868 }
20869
20870
20871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
20872   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20873   Dali::PropertyNotification arg2 ;
20874   Dali::PropertyNotification *argp2 ;
20875
20876   arg1 = (Dali::Handle *)jarg1;
20877   argp2 = (Dali::PropertyNotification *)jarg2;
20878   if (!argp2) {
20879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
20880     return ;
20881   }
20882   arg2 = *argp2;
20883   {
20884     try {
20885       (arg1)->RemovePropertyNotification(arg2);
20886     } catch (std::out_of_range& e) {
20887       {
20888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20889       };
20890     } catch (std::exception& e) {
20891       {
20892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20893       };
20894     } catch (Dali::DaliException e) {
20895       {
20896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20897       };
20898     } catch (...) {
20899       {
20900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20901       };
20902     }
20903   }
20904
20905 }
20906
20907
20908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
20909   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20910
20911   arg1 = (Dali::Handle *)jarg1;
20912   {
20913     try {
20914       (arg1)->RemovePropertyNotifications();
20915     } catch (std::out_of_range& e) {
20916       {
20917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20918       };
20919     } catch (std::exception& e) {
20920       {
20921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20922       };
20923     } catch (Dali::DaliException e) {
20924       {
20925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20926       };
20927     } catch (...) {
20928       {
20929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20930       };
20931     }
20932   }
20933
20934 }
20935
20936
20937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
20938   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20939
20940   arg1 = (Dali::Handle *)jarg1;
20941   {
20942     try {
20943       (arg1)->RemoveConstraints();
20944     } catch (std::out_of_range& e) {
20945       {
20946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20947       };
20948     } catch (std::exception& e) {
20949       {
20950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20951       };
20952     } catch (Dali::DaliException e) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20959       };
20960     }
20961   }
20962
20963 }
20964
20965
20966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
20967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20968   unsigned int arg2 ;
20969
20970   arg1 = (Dali::Handle *)jarg1;
20971   arg2 = (unsigned int)jarg2;
20972   {
20973     try {
20974       (arg1)->RemoveConstraints(arg2);
20975     } catch (std::out_of_range& e) {
20976       {
20977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20978       };
20979     } catch (std::exception& e) {
20980       {
20981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20982       };
20983     } catch (Dali::DaliException e) {
20984       {
20985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20986       };
20987     } catch (...) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20990       };
20991     }
20992   }
20993
20994 }
20995
20996
20997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
20998   int jresult ;
20999   Dali::Property::Index result;
21000
21001   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21002   jresult = result;
21003   return jresult;
21004 }
21005
21006
21007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21008   void * jresult ;
21009   Dali::Handle result;
21010
21011   {
21012     try {
21013       result = Dali::WeightObject::New();
21014     } catch (std::out_of_range& e) {
21015       {
21016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21017       };
21018     } catch (std::exception& e) {
21019       {
21020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21021       };
21022     } catch (Dali::DaliException e) {
21023       {
21024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21025       };
21026     } catch (...) {
21027       {
21028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21029       };
21030     }
21031   }
21032
21033   jresult = new Dali::Handle((const Dali::Handle &)result);
21034   return jresult;
21035 }
21036
21037
21038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21039   void * jresult ;
21040   Dali::TypeInfo *result = 0 ;
21041
21042   {
21043     try {
21044       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21045     } catch (std::out_of_range& e) {
21046       {
21047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21048       };
21049     } catch (std::exception& e) {
21050       {
21051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21052       };
21053     } catch (Dali::DaliException e) {
21054       {
21055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21056       };
21057     } catch (...) {
21058       {
21059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21060       };
21061     }
21062   }
21063
21064   jresult = (void *)result;
21065   return jresult;
21066 }
21067
21068
21069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21070   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21071
21072   arg1 = (Dali::TypeInfo *)jarg1;
21073   {
21074     try {
21075       delete arg1;
21076     } catch (std::out_of_range& e) {
21077       {
21078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21079       };
21080     } catch (std::exception& e) {
21081       {
21082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (Dali::DaliException e) {
21085       {
21086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21087       };
21088     } catch (...) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21091       };
21092     }
21093   }
21094
21095 }
21096
21097
21098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21099   void * jresult ;
21100   Dali::TypeInfo *arg1 = 0 ;
21101   Dali::TypeInfo *result = 0 ;
21102
21103   arg1 = (Dali::TypeInfo *)jarg1;
21104   if (!arg1) {
21105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21106     return 0;
21107   }
21108   {
21109     try {
21110       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21111     } catch (std::out_of_range& e) {
21112       {
21113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21114       };
21115     } catch (std::exception& e) {
21116       {
21117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21118       };
21119     } catch (Dali::DaliException e) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21122       };
21123     } catch (...) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21126       };
21127     }
21128   }
21129
21130   jresult = (void *)result;
21131   return jresult;
21132 }
21133
21134
21135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21136   void * jresult ;
21137   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21138   Dali::TypeInfo *arg2 = 0 ;
21139   Dali::TypeInfo *result = 0 ;
21140
21141   arg1 = (Dali::TypeInfo *)jarg1;
21142   arg2 = (Dali::TypeInfo *)jarg2;
21143   if (!arg2) {
21144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21145     return 0;
21146   }
21147   {
21148     try {
21149       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21150     } catch (std::out_of_range& e) {
21151       {
21152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21153       };
21154     } catch (std::exception& e) {
21155       {
21156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (Dali::DaliException e) {
21159       {
21160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21161       };
21162     } catch (...) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21165       };
21166     }
21167   }
21168
21169   jresult = (void *)result;
21170   return jresult;
21171 }
21172
21173
21174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21175   char * jresult ;
21176   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21177   std::string *result = 0 ;
21178
21179   arg1 = (Dali::TypeInfo *)jarg1;
21180   {
21181     try {
21182       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21183     } catch (std::out_of_range& e) {
21184       {
21185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (std::exception& e) {
21188       {
21189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21190       };
21191     } catch (Dali::DaliException e) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21198       };
21199     }
21200   }
21201
21202   jresult = SWIG_csharp_string_callback(result->c_str());
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21208   char * jresult ;
21209   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21210   std::string *result = 0 ;
21211
21212   arg1 = (Dali::TypeInfo *)jarg1;
21213   {
21214     try {
21215       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21223       };
21224     } catch (Dali::DaliException e) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21231       };
21232     }
21233   }
21234
21235   jresult = SWIG_csharp_string_callback(result->c_str());
21236   return jresult;
21237 }
21238
21239
21240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21241   void * jresult ;
21242   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21243   Dali::BaseHandle result;
21244
21245   arg1 = (Dali::TypeInfo *)jarg1;
21246   {
21247     try {
21248       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (Dali::DaliException e) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21260       };
21261     } catch (...) {
21262       {
21263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21264       };
21265     }
21266   }
21267
21268   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21274   unsigned long jresult ;
21275   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21276   size_t result;
21277
21278   arg1 = (Dali::TypeInfo *)jarg1;
21279   {
21280     try {
21281       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21282     } catch (std::out_of_range& e) {
21283       {
21284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21285       };
21286     } catch (std::exception& e) {
21287       {
21288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21289       };
21290     } catch (Dali::DaliException e) {
21291       {
21292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21293       };
21294     } catch (...) {
21295       {
21296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21297       };
21298     }
21299   }
21300
21301   jresult = (unsigned long)result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21307   char * jresult ;
21308   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21309   size_t arg2 ;
21310   std::string result;
21311
21312   arg1 = (Dali::TypeInfo *)jarg1;
21313   arg2 = (size_t)jarg2;
21314   {
21315     try {
21316       result = (arg1)->GetActionName(arg2);
21317     } catch (std::out_of_range& e) {
21318       {
21319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21320       };
21321     } catch (std::exception& e) {
21322       {
21323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (Dali::DaliException e) {
21326       {
21327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21328       };
21329     } catch (...) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21332       };
21333     }
21334   }
21335
21336   jresult = SWIG_csharp_string_callback((&result)->c_str());
21337   return jresult;
21338 }
21339
21340
21341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21342   unsigned long jresult ;
21343   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21344   size_t result;
21345
21346   arg1 = (Dali::TypeInfo *)jarg1;
21347   {
21348     try {
21349       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21350     } catch (std::out_of_range& e) {
21351       {
21352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21353       };
21354     } catch (std::exception& e) {
21355       {
21356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (Dali::DaliException e) {
21359       {
21360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21361       };
21362     } catch (...) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21365       };
21366     }
21367   }
21368
21369   jresult = (unsigned long)result;
21370   return jresult;
21371 }
21372
21373
21374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21375   char * jresult ;
21376   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21377   size_t arg2 ;
21378   std::string result;
21379
21380   arg1 = (Dali::TypeInfo *)jarg1;
21381   arg2 = (size_t)jarg2;
21382   {
21383     try {
21384       result = (arg1)->GetSignalName(arg2);
21385     } catch (std::out_of_range& e) {
21386       {
21387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (std::exception& e) {
21390       {
21391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (Dali::DaliException e) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21396       };
21397     } catch (...) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21400       };
21401     }
21402   }
21403
21404   jresult = SWIG_csharp_string_callback((&result)->c_str());
21405   return jresult;
21406 }
21407
21408
21409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21410   unsigned long jresult ;
21411   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21412   size_t result;
21413
21414   arg1 = (Dali::TypeInfo *)jarg1;
21415   {
21416     try {
21417       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21418     } catch (std::out_of_range& e) {
21419       {
21420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21421       };
21422     } catch (std::exception& e) {
21423       {
21424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (Dali::DaliException e) {
21427       {
21428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21429       };
21430     } catch (...) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21433       };
21434     }
21435   }
21436
21437   jresult = (unsigned long)result;
21438   return jresult;
21439 }
21440
21441
21442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21443   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21444   Dali::Property::IndexContainer *arg2 = 0 ;
21445
21446   arg1 = (Dali::TypeInfo *)jarg1;
21447   arg2 = (Dali::Property::IndexContainer *)jarg2;
21448   if (!arg2) {
21449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21450     return ;
21451   }
21452   {
21453     try {
21454       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21462       };
21463     } catch (Dali::DaliException e) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21466       };
21467     } catch (...) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21470       };
21471     }
21472   }
21473
21474 }
21475
21476
21477 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21478   char * jresult ;
21479   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21480   Dali::Property::Index arg2 ;
21481   std::string *result = 0 ;
21482
21483   arg1 = (Dali::TypeInfo *)jarg1;
21484   arg2 = (Dali::Property::Index)jarg2;
21485   {
21486     try {
21487       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (Dali::DaliException e) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21499       };
21500     } catch (...) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21503       };
21504     }
21505   }
21506
21507   jresult = SWIG_csharp_string_callback(result->c_str());
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21513   void * jresult ;
21514   Dali::TypeRegistry result;
21515
21516   {
21517     try {
21518       result = Dali::TypeRegistry::Get();
21519     } catch (std::out_of_range& e) {
21520       {
21521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21522       };
21523     } catch (std::exception& e) {
21524       {
21525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (Dali::DaliException e) {
21528       {
21529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21530       };
21531     } catch (...) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21534       };
21535     }
21536   }
21537
21538   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21539   return jresult;
21540 }
21541
21542
21543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21544   void * jresult ;
21545   Dali::TypeRegistry *result = 0 ;
21546
21547   {
21548     try {
21549       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21550     } catch (std::out_of_range& e) {
21551       {
21552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21553       };
21554     } catch (std::exception& e) {
21555       {
21556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21557       };
21558     } catch (Dali::DaliException e) {
21559       {
21560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21561       };
21562     } catch (...) {
21563       {
21564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21565       };
21566     }
21567   }
21568
21569   jresult = (void *)result;
21570   return jresult;
21571 }
21572
21573
21574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21575   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21576
21577   arg1 = (Dali::TypeRegistry *)jarg1;
21578   {
21579     try {
21580       delete arg1;
21581     } catch (std::out_of_range& e) {
21582       {
21583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21584       };
21585     } catch (std::exception& e) {
21586       {
21587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21588       };
21589     } catch (Dali::DaliException e) {
21590       {
21591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21592       };
21593     } catch (...) {
21594       {
21595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21596       };
21597     }
21598   }
21599
21600 }
21601
21602
21603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21604   void * jresult ;
21605   Dali::TypeRegistry *arg1 = 0 ;
21606   Dali::TypeRegistry *result = 0 ;
21607
21608   arg1 = (Dali::TypeRegistry *)jarg1;
21609   if (!arg1) {
21610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21611     return 0;
21612   }
21613   {
21614     try {
21615       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21616     } catch (std::out_of_range& e) {
21617       {
21618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (std::exception& e) {
21621       {
21622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21623       };
21624     } catch (Dali::DaliException e) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21627       };
21628     } catch (...) {
21629       {
21630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21631       };
21632     }
21633   }
21634
21635   jresult = (void *)result;
21636   return jresult;
21637 }
21638
21639
21640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21641   void * jresult ;
21642   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21643   Dali::TypeRegistry *arg2 = 0 ;
21644   Dali::TypeRegistry *result = 0 ;
21645
21646   arg1 = (Dali::TypeRegistry *)jarg1;
21647   arg2 = (Dali::TypeRegistry *)jarg2;
21648   if (!arg2) {
21649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21650     return 0;
21651   }
21652   {
21653     try {
21654       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21655     } catch (std::out_of_range& e) {
21656       {
21657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (std::exception& e) {
21660       {
21661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (Dali::DaliException e) {
21664       {
21665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21666       };
21667     } catch (...) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21670       };
21671     }
21672   }
21673
21674   jresult = (void *)result;
21675   return jresult;
21676 }
21677
21678
21679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21680   void * jresult ;
21681   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21682   std::string *arg2 = 0 ;
21683   Dali::TypeInfo result;
21684
21685   arg1 = (Dali::TypeRegistry *)jarg1;
21686   if (!jarg2) {
21687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21688     return 0;
21689   }
21690   std::string arg2_str(jarg2);
21691   arg2 = &arg2_str;
21692   {
21693     try {
21694       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21695     } catch (std::out_of_range& e) {
21696       {
21697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21698       };
21699     } catch (std::exception& e) {
21700       {
21701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (Dali::DaliException e) {
21704       {
21705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713
21714   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21715
21716   //argout typemap for const std::string&
21717
21718   return jresult;
21719 }
21720
21721
21722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21723   void * jresult ;
21724   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21725   std::type_info *arg2 = 0 ;
21726   Dali::TypeInfo result;
21727
21728   arg1 = (Dali::TypeRegistry *)jarg1;
21729   arg2 = (std::type_info *)jarg2;
21730   if (!arg2) {
21731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21732     return 0;
21733   }
21734   {
21735     try {
21736       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21737     } catch (std::out_of_range& e) {
21738       {
21739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21740       };
21741     } catch (std::exception& e) {
21742       {
21743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21744       };
21745     } catch (Dali::DaliException e) {
21746       {
21747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21748       };
21749     } catch (...) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21752       };
21753     }
21754   }
21755
21756   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21757   return jresult;
21758 }
21759
21760
21761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21762   unsigned long jresult ;
21763   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21764   size_t result;
21765
21766   arg1 = (Dali::TypeRegistry *)jarg1;
21767   {
21768     try {
21769       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21770     } catch (std::out_of_range& e) {
21771       {
21772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21773       };
21774     } catch (std::exception& e) {
21775       {
21776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (Dali::DaliException e) {
21779       {
21780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21781       };
21782     } catch (...) {
21783       {
21784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21785       };
21786     }
21787   }
21788
21789   jresult = (unsigned long)result;
21790   return jresult;
21791 }
21792
21793
21794 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21795   char * jresult ;
21796   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21797   size_t arg2 ;
21798   std::string result;
21799
21800   arg1 = (Dali::TypeRegistry *)jarg1;
21801   arg2 = (size_t)jarg2;
21802   {
21803     try {
21804       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21805     } catch (std::out_of_range& e) {
21806       {
21807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21808       };
21809     } catch (std::exception& e) {
21810       {
21811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21812       };
21813     } catch (Dali::DaliException e) {
21814       {
21815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21816       };
21817     } catch (...) {
21818       {
21819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21820       };
21821     }
21822   }
21823
21824   jresult = SWIG_csharp_string_callback((&result)->c_str());
21825   return jresult;
21826 }
21827
21828
21829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21830   void * jresult ;
21831   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21832   Dali::TypeRegistry *result = 0 ;
21833
21834   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21835   {
21836     try {
21837       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
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_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21863   void * jresult ;
21864   std::type_info *arg1 = 0 ;
21865   std::type_info *arg2 = 0 ;
21866   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21867   Dali::TypeRegistration *result = 0 ;
21868
21869   arg1 = (std::type_info *)jarg1;
21870   if (!arg1) {
21871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21872     return 0;
21873   }
21874   arg2 = (std::type_info *)jarg2;
21875   if (!arg2) {
21876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21877     return 0;
21878   }
21879   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21880   {
21881     try {
21882       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21883     } catch (std::out_of_range& e) {
21884       {
21885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21886       };
21887     } catch (std::exception& e) {
21888       {
21889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21890       };
21891     } catch (Dali::DaliException e) {
21892       {
21893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21894       };
21895     } catch (...) {
21896       {
21897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21898       };
21899     }
21900   }
21901
21902   jresult = (void *)result;
21903   return jresult;
21904 }
21905
21906
21907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
21908   void * jresult ;
21909   std::type_info *arg1 = 0 ;
21910   std::type_info *arg2 = 0 ;
21911   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21912   bool arg4 ;
21913   Dali::TypeRegistration *result = 0 ;
21914
21915   arg1 = (std::type_info *)jarg1;
21916   if (!arg1) {
21917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21918     return 0;
21919   }
21920   arg2 = (std::type_info *)jarg2;
21921   if (!arg2) {
21922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21923     return 0;
21924   }
21925   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21926   arg4 = jarg4 ? true : false;
21927   {
21928     try {
21929       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
21930     } catch (std::out_of_range& e) {
21931       {
21932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21933       };
21934     } catch (std::exception& e) {
21935       {
21936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21937       };
21938     } catch (Dali::DaliException e) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21941       };
21942     } catch (...) {
21943       {
21944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21945       };
21946     }
21947   }
21948
21949   jresult = (void *)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
21955   void * jresult ;
21956   std::string *arg1 = 0 ;
21957   std::type_info *arg2 = 0 ;
21958   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21959   Dali::TypeRegistration *result = 0 ;
21960
21961   if (!jarg1) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21963     return 0;
21964   }
21965   std::string arg1_str(jarg1);
21966   arg1 = &arg1_str;
21967   arg2 = (std::type_info *)jarg2;
21968   if (!arg2) {
21969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21970     return 0;
21971   }
21972   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21973   {
21974     try {
21975       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
21976     } catch (std::out_of_range& e) {
21977       {
21978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21979       };
21980     } catch (std::exception& e) {
21981       {
21982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21983       };
21984     } catch (Dali::DaliException e) {
21985       {
21986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21987       };
21988     } catch (...) {
21989       {
21990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21991       };
21992     }
21993   }
21994
21995   jresult = (void *)result;
21996
21997   //argout typemap for const std::string&
21998
21999   return jresult;
22000 }
22001
22002
22003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22004   char * jresult ;
22005   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22006   std::string result;
22007
22008   arg1 = (Dali::TypeRegistration *)jarg1;
22009   {
22010     try {
22011       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22012     } catch (std::out_of_range& e) {
22013       {
22014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (std::exception& e) {
22017       {
22018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22019       };
22020     } catch (Dali::DaliException e) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22023       };
22024     } catch (...) {
22025       {
22026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22027       };
22028     }
22029   }
22030
22031   jresult = SWIG_csharp_string_callback((&result)->c_str());
22032   return jresult;
22033 }
22034
22035
22036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22037   std::string *arg1 = 0 ;
22038   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22039
22040   if (!jarg1) {
22041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22042     return ;
22043   }
22044   std::string arg1_str(jarg1);
22045   arg1 = &arg1_str;
22046   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22047   {
22048     try {
22049       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22050     } catch (std::out_of_range& e) {
22051       {
22052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22053       };
22054     } catch (std::exception& e) {
22055       {
22056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22057       };
22058     } catch (Dali::DaliException e) {
22059       {
22060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22061       };
22062     } catch (...) {
22063       {
22064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22065       };
22066     }
22067   }
22068
22069
22070   //argout typemap for const std::string&
22071
22072 }
22073
22074
22075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22076   std::string *arg1 = 0 ;
22077   std::string *arg2 = 0 ;
22078   int arg3 ;
22079   Dali::Property::Type arg4 ;
22080   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22081   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22082
22083   if (!jarg1) {
22084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22085     return ;
22086   }
22087   std::string arg1_str(jarg1);
22088   arg1 = &arg1_str;
22089   if (!jarg2) {
22090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22091     return ;
22092   }
22093   std::string arg2_str(jarg2);
22094   arg2 = &arg2_str;
22095   arg3 = (int)jarg3;
22096   arg4 = (Dali::Property::Type)jarg4;
22097   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22098   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22099   {
22100     try {
22101       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22102     } catch (std::out_of_range& e) {
22103       {
22104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22105       };
22106     } catch (std::exception& e) {
22107       {
22108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22109       };
22110     } catch (Dali::DaliException e) {
22111       {
22112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22113       };
22114     } catch (...) {
22115       {
22116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22117       };
22118     }
22119   }
22120
22121
22122   //argout typemap for const std::string&
22123
22124
22125   //argout typemap for const std::string&
22126
22127 }
22128
22129
22130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22131   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22132
22133   arg1 = (Dali::TypeRegistration *)jarg1;
22134   {
22135     try {
22136       delete arg1;
22137     } catch (std::out_of_range& e) {
22138       {
22139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22140       };
22141     } catch (std::exception& e) {
22142       {
22143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22144       };
22145     } catch (Dali::DaliException e) {
22146       {
22147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22152       };
22153     }
22154   }
22155
22156 }
22157
22158
22159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22160   void * jresult ;
22161   Dali::TypeRegistration *arg1 = 0 ;
22162   std::string *arg2 = 0 ;
22163   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22164   Dali::SignalConnectorType *result = 0 ;
22165
22166   arg1 = (Dali::TypeRegistration *)jarg1;
22167   if (!arg1) {
22168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22169     return 0;
22170   }
22171   if (!jarg2) {
22172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22173     return 0;
22174   }
22175   std::string arg2_str(jarg2);
22176   arg2 = &arg2_str;
22177   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22178   {
22179     try {
22180       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22181     } catch (std::out_of_range& e) {
22182       {
22183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22184       };
22185     } catch (std::exception& e) {
22186       {
22187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22188       };
22189     } catch (Dali::DaliException e) {
22190       {
22191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22192       };
22193     } catch (...) {
22194       {
22195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22196       };
22197     }
22198   }
22199
22200   jresult = (void *)result;
22201
22202   //argout typemap for const std::string&
22203
22204   return jresult;
22205 }
22206
22207
22208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22209   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22210
22211   arg1 = (Dali::SignalConnectorType *)jarg1;
22212   {
22213     try {
22214       delete arg1;
22215     } catch (std::out_of_range& e) {
22216       {
22217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22218       };
22219     } catch (std::exception& e) {
22220       {
22221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22222       };
22223     } catch (Dali::DaliException e) {
22224       {
22225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22226       };
22227     } catch (...) {
22228       {
22229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22230       };
22231     }
22232   }
22233
22234 }
22235
22236
22237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22238   void * jresult ;
22239   Dali::TypeRegistration *arg1 = 0 ;
22240   std::string *arg2 = 0 ;
22241   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22242   Dali::TypeAction *result = 0 ;
22243
22244   arg1 = (Dali::TypeRegistration *)jarg1;
22245   if (!arg1) {
22246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22247     return 0;
22248   }
22249   if (!jarg2) {
22250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22251     return 0;
22252   }
22253   std::string arg2_str(jarg2);
22254   arg2 = &arg2_str;
22255   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22256   {
22257     try {
22258       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22259     } catch (std::out_of_range& e) {
22260       {
22261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22262       };
22263     } catch (std::exception& e) {
22264       {
22265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22266       };
22267     } catch (Dali::DaliException e) {
22268       {
22269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22270       };
22271     } catch (...) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22274       };
22275     }
22276   }
22277
22278   jresult = (void *)result;
22279
22280   //argout typemap for const std::string&
22281
22282   return jresult;
22283 }
22284
22285
22286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22287   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22288
22289   arg1 = (Dali::TypeAction *)jarg1;
22290   {
22291     try {
22292       delete arg1;
22293     } catch (std::out_of_range& e) {
22294       {
22295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22296       };
22297     } catch (std::exception& e) {
22298       {
22299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22300       };
22301     } catch (Dali::DaliException e) {
22302       {
22303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22304       };
22305     } catch (...) {
22306       {
22307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22308       };
22309     }
22310   }
22311
22312 }
22313
22314
22315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22316   void * jresult ;
22317   Dali::TypeRegistration *arg1 = 0 ;
22318   std::string *arg2 = 0 ;
22319   Dali::Property::Index arg3 ;
22320   Dali::Property::Type arg4 ;
22321   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22322   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22323   Dali::PropertyRegistration *result = 0 ;
22324
22325   arg1 = (Dali::TypeRegistration *)jarg1;
22326   if (!arg1) {
22327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22328     return 0;
22329   }
22330   if (!jarg2) {
22331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22332     return 0;
22333   }
22334   std::string arg2_str(jarg2);
22335   arg2 = &arg2_str;
22336   arg3 = (Dali::Property::Index)jarg3;
22337   arg4 = (Dali::Property::Type)jarg4;
22338   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22339   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22340   {
22341     try {
22342       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22343     } catch (std::out_of_range& e) {
22344       {
22345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22346       };
22347     } catch (std::exception& e) {
22348       {
22349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22350       };
22351     } catch (Dali::DaliException e) {
22352       {
22353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22354       };
22355     } catch (...) {
22356       {
22357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22358       };
22359     }
22360   }
22361
22362   jresult = (void *)result;
22363
22364   //argout typemap for const std::string&
22365
22366   return jresult;
22367 }
22368
22369
22370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22371   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22372
22373   arg1 = (Dali::PropertyRegistration *)jarg1;
22374   {
22375     try {
22376       delete arg1;
22377     } catch (std::out_of_range& e) {
22378       {
22379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22380       };
22381     } catch (std::exception& e) {
22382       {
22383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22384       };
22385     } catch (Dali::DaliException e) {
22386       {
22387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22388       };
22389     } catch (...) {
22390       {
22391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22392       };
22393     }
22394   }
22395
22396 }
22397
22398
22399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22400   void * jresult ;
22401   Dali::TypeRegistration *arg1 = 0 ;
22402   std::string *arg2 = 0 ;
22403   Dali::Property::Index arg3 ;
22404   Dali::Property::Type arg4 ;
22405   Dali::AnimatablePropertyRegistration *result = 0 ;
22406
22407   arg1 = (Dali::TypeRegistration *)jarg1;
22408   if (!arg1) {
22409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22410     return 0;
22411   }
22412   if (!jarg2) {
22413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22414     return 0;
22415   }
22416   std::string arg2_str(jarg2);
22417   arg2 = &arg2_str;
22418   arg3 = (Dali::Property::Index)jarg3;
22419   arg4 = (Dali::Property::Type)jarg4;
22420   {
22421     try {
22422       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22423     } catch (std::out_of_range& e) {
22424       {
22425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22426       };
22427     } catch (std::exception& e) {
22428       {
22429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22430       };
22431     } catch (Dali::DaliException e) {
22432       {
22433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22434       };
22435     } catch (...) {
22436       {
22437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22438       };
22439     }
22440   }
22441
22442   jresult = (void *)result;
22443
22444   //argout typemap for const std::string&
22445
22446   return jresult;
22447 }
22448
22449
22450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22451   void * jresult ;
22452   Dali::TypeRegistration *arg1 = 0 ;
22453   std::string *arg2 = 0 ;
22454   Dali::Property::Index arg3 ;
22455   Dali::Property::Value *arg4 = 0 ;
22456   Dali::AnimatablePropertyRegistration *result = 0 ;
22457
22458   arg1 = (Dali::TypeRegistration *)jarg1;
22459   if (!arg1) {
22460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22461     return 0;
22462   }
22463   if (!jarg2) {
22464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22465     return 0;
22466   }
22467   std::string arg2_str(jarg2);
22468   arg2 = &arg2_str;
22469   arg3 = (Dali::Property::Index)jarg3;
22470   arg4 = (Dali::Property::Value *)jarg4;
22471   if (!arg4) {
22472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22473     return 0;
22474   }
22475   {
22476     try {
22477       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22478     } catch (std::out_of_range& e) {
22479       {
22480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22481       };
22482     } catch (std::exception& e) {
22483       {
22484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22485       };
22486     } catch (Dali::DaliException e) {
22487       {
22488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22489       };
22490     } catch (...) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22493       };
22494     }
22495   }
22496
22497   jresult = (void *)result;
22498
22499   //argout typemap for const std::string&
22500
22501   return jresult;
22502 }
22503
22504
22505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22506   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22507
22508   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22509   {
22510     try {
22511       delete arg1;
22512     } catch (std::out_of_range& e) {
22513       {
22514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22515       };
22516     } catch (std::exception& e) {
22517       {
22518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22519       };
22520     } catch (Dali::DaliException e) {
22521       {
22522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22523       };
22524     } catch (...) {
22525       {
22526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22527       };
22528     }
22529   }
22530
22531 }
22532
22533
22534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22535   void * jresult ;
22536   Dali::TypeRegistration *arg1 = 0 ;
22537   std::string *arg2 = 0 ;
22538   Dali::Property::Index arg3 ;
22539   Dali::Property::Index arg4 ;
22540   unsigned int arg5 ;
22541   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22542
22543   arg1 = (Dali::TypeRegistration *)jarg1;
22544   if (!arg1) {
22545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22546     return 0;
22547   }
22548   if (!jarg2) {
22549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22550     return 0;
22551   }
22552   std::string arg2_str(jarg2);
22553   arg2 = &arg2_str;
22554   arg3 = (Dali::Property::Index)jarg3;
22555   arg4 = (Dali::Property::Index)jarg4;
22556   arg5 = (unsigned int)jarg5;
22557   {
22558     try {
22559       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22560     } catch (std::out_of_range& e) {
22561       {
22562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22563       };
22564     } catch (std::exception& e) {
22565       {
22566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22567       };
22568     } catch (Dali::DaliException e) {
22569       {
22570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22571       };
22572     } catch (...) {
22573       {
22574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22575       };
22576     }
22577   }
22578
22579   jresult = (void *)result;
22580
22581   //argout typemap for const std::string&
22582
22583   return jresult;
22584 }
22585
22586
22587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22588   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22589
22590   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22591   {
22592     try {
22593       delete arg1;
22594     } catch (std::out_of_range& e) {
22595       {
22596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22597       };
22598     } catch (std::exception& e) {
22599       {
22600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22601       };
22602     } catch (Dali::DaliException e) {
22603       {
22604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22605       };
22606     } catch (...) {
22607       {
22608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22609       };
22610     }
22611   }
22612
22613 }
22614
22615
22616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22617   void * jresult ;
22618   Dali::TypeRegistration *arg1 = 0 ;
22619   std::string *arg2 = 0 ;
22620   Dali::Property::Index arg3 ;
22621   Dali::Property::Type arg4 ;
22622   Dali::ChildPropertyRegistration *result = 0 ;
22623
22624   arg1 = (Dali::TypeRegistration *)jarg1;
22625   if (!arg1) {
22626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22627     return 0;
22628   }
22629   if (!jarg2) {
22630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22631     return 0;
22632   }
22633   std::string arg2_str(jarg2);
22634   arg2 = &arg2_str;
22635   arg3 = (Dali::Property::Index)jarg3;
22636   arg4 = (Dali::Property::Type)jarg4;
22637   {
22638     try {
22639       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22640     } catch (std::out_of_range& e) {
22641       {
22642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22643       };
22644     } catch (std::exception& e) {
22645       {
22646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22647       };
22648     } catch (Dali::DaliException e) {
22649       {
22650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22651       };
22652     } catch (...) {
22653       {
22654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22655       };
22656     }
22657   }
22658
22659   jresult = (void *)result;
22660
22661   //argout typemap for const std::string&
22662
22663   return jresult;
22664 }
22665
22666
22667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22668   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22669
22670   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22671   {
22672     try {
22673       delete arg1;
22674     } catch (std::out_of_range& e) {
22675       {
22676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22677       };
22678     } catch (std::exception& e) {
22679       {
22680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22681       };
22682     } catch (Dali::DaliException e) {
22683       {
22684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22685       };
22686     } catch (...) {
22687       {
22688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22689       };
22690     }
22691   }
22692
22693 }
22694
22695
22696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22697   unsigned int jresult ;
22698   std::string *arg1 = 0 ;
22699   std::type_info *arg2 = 0 ;
22700   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22701   bool result;
22702
22703   if (!jarg1) {
22704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22705     return 0;
22706   }
22707   std::string arg1_str(jarg1);
22708   arg1 = &arg1_str;
22709   arg2 = (std::type_info *)jarg2;
22710   if (!arg2) {
22711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22712     return 0;
22713   }
22714   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22715   {
22716     try {
22717       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22725       };
22726     } catch (Dali::DaliException e) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22729       };
22730     } catch (...) {
22731       {
22732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22733       };
22734     }
22735   }
22736
22737   jresult = result;
22738
22739   //argout typemap for const std::string&
22740
22741   return jresult;
22742 }
22743
22744
22745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22746   unsigned int jresult ;
22747   std::string *arg1 = 0 ;
22748   std::string *arg2 = 0 ;
22749   Dali::Property::Index arg3 ;
22750   Dali::Property::Type arg4 ;
22751   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22752   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22753   bool result;
22754
22755   if (!jarg1) {
22756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22757     return 0;
22758   }
22759   std::string arg1_str(jarg1);
22760   arg1 = &arg1_str;
22761   if (!jarg2) {
22762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22763     return 0;
22764   }
22765   std::string arg2_str(jarg2);
22766   arg2 = &arg2_str;
22767   arg3 = (Dali::Property::Index)jarg3;
22768   arg4 = (Dali::Property::Type)jarg4;
22769   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22770   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22771   {
22772     try {
22773       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22774     } catch (std::out_of_range& e) {
22775       {
22776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22777       };
22778     } catch (std::exception& e) {
22779       {
22780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22781       };
22782     } catch (Dali::DaliException e) {
22783       {
22784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22785       };
22786     } catch (...) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22789       };
22790     }
22791   }
22792
22793   jresult = result;
22794
22795   //argout typemap for const std::string&
22796
22797
22798   //argout typemap for const std::string&
22799
22800   return jresult;
22801 }
22802
22803
22804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22805   float jresult ;
22806   float result;
22807
22808   result = (float)(float)Dali::ParentOrigin::TOP;
22809   jresult = result;
22810   return jresult;
22811 }
22812
22813
22814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22815   float jresult ;
22816   float result;
22817
22818   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22819   jresult = result;
22820   return jresult;
22821 }
22822
22823
22824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22825   float jresult ;
22826   float result;
22827
22828   result = (float)(float)Dali::ParentOrigin::LEFT;
22829   jresult = result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22835   float jresult ;
22836   float result;
22837
22838   result = (float)(float)Dali::ParentOrigin::RIGHT;
22839   jresult = result;
22840   return jresult;
22841 }
22842
22843
22844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22845   float jresult ;
22846   float result;
22847
22848   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22849   jresult = result;
22850   return jresult;
22851 }
22852
22853
22854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22855   void * jresult ;
22856   Dali::Vector3 *result = 0 ;
22857
22858   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22859   jresult = (void *)result;
22860   return jresult;
22861 }
22862
22863
22864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22865   void * jresult ;
22866   Dali::Vector3 *result = 0 ;
22867
22868   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22869   jresult = (void *)result;
22870   return jresult;
22871 }
22872
22873
22874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22875   void * jresult ;
22876   Dali::Vector3 *result = 0 ;
22877
22878   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22879   jresult = (void *)result;
22880   return jresult;
22881 }
22882
22883
22884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22885   void * jresult ;
22886   Dali::Vector3 *result = 0 ;
22887
22888   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22889   jresult = (void *)result;
22890   return jresult;
22891 }
22892
22893
22894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22895   void * jresult ;
22896   Dali::Vector3 *result = 0 ;
22897
22898   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
22899   jresult = (void *)result;
22900   return jresult;
22901 }
22902
22903
22904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
22905   void * jresult ;
22906   Dali::Vector3 *result = 0 ;
22907
22908   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
22909   jresult = (void *)result;
22910   return jresult;
22911 }
22912
22913
22914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
22915   void * jresult ;
22916   Dali::Vector3 *result = 0 ;
22917
22918   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
22919   jresult = (void *)result;
22920   return jresult;
22921 }
22922
22923
22924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
22925   void * jresult ;
22926   Dali::Vector3 *result = 0 ;
22927
22928   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
22929   jresult = (void *)result;
22930   return jresult;
22931 }
22932
22933
22934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
22935   void * jresult ;
22936   Dali::Vector3 *result = 0 ;
22937
22938   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
22939   jresult = (void *)result;
22940   return jresult;
22941 }
22942
22943
22944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
22945   float jresult ;
22946   float result;
22947
22948   result = (float)(float)Dali::AnchorPoint::TOP;
22949   jresult = result;
22950   return jresult;
22951 }
22952
22953
22954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
22955   float jresult ;
22956   float result;
22957
22958   result = (float)(float)Dali::AnchorPoint::BOTTOM;
22959   jresult = result;
22960   return jresult;
22961 }
22962
22963
22964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
22965   float jresult ;
22966   float result;
22967
22968   result = (float)(float)Dali::AnchorPoint::LEFT;
22969   jresult = result;
22970   return jresult;
22971 }
22972
22973
22974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
22975   float jresult ;
22976   float result;
22977
22978   result = (float)(float)Dali::AnchorPoint::RIGHT;
22979   jresult = result;
22980   return jresult;
22981 }
22982
22983
22984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
22985   float jresult ;
22986   float result;
22987
22988   result = (float)(float)Dali::AnchorPoint::MIDDLE;
22989   jresult = result;
22990   return jresult;
22991 }
22992
22993
22994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
22995   void * jresult ;
22996   Dali::Vector3 *result = 0 ;
22997
22998   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
22999   jresult = (void *)result;
23000   return jresult;
23001 }
23002
23003
23004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23005   void * jresult ;
23006   Dali::Vector3 *result = 0 ;
23007
23008   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23009   jresult = (void *)result;
23010   return jresult;
23011 }
23012
23013
23014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23015   void * jresult ;
23016   Dali::Vector3 *result = 0 ;
23017
23018   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23019   jresult = (void *)result;
23020   return jresult;
23021 }
23022
23023
23024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23025   void * jresult ;
23026   Dali::Vector3 *result = 0 ;
23027
23028   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23029   jresult = (void *)result;
23030   return jresult;
23031 }
23032
23033
23034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23035   void * jresult ;
23036   Dali::Vector3 *result = 0 ;
23037
23038   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23039   jresult = (void *)result;
23040   return jresult;
23041 }
23042
23043
23044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23045   void * jresult ;
23046   Dali::Vector3 *result = 0 ;
23047
23048   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23049   jresult = (void *)result;
23050   return jresult;
23051 }
23052
23053
23054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23055   void * jresult ;
23056   Dali::Vector3 *result = 0 ;
23057
23058   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23059   jresult = (void *)result;
23060   return jresult;
23061 }
23062
23063
23064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23065   void * jresult ;
23066   Dali::Vector3 *result = 0 ;
23067
23068   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23069   jresult = (void *)result;
23070   return jresult;
23071 }
23072
23073
23074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23075   void * jresult ;
23076   Dali::Vector3 *result = 0 ;
23077
23078   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23079   jresult = (void *)result;
23080   return jresult;
23081 }
23082
23083
23084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23085   void * jresult ;
23086   Dali::Vector4 *result = 0 ;
23087
23088   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23089   jresult = (void *)result;
23090   return jresult;
23091 }
23092
23093
23094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23095   void * jresult ;
23096   Dali::Vector4 *result = 0 ;
23097
23098   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23099   jresult = (void *)result;
23100   return jresult;
23101 }
23102
23103
23104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23105   void * jresult ;
23106   Dali::Vector4 *result = 0 ;
23107
23108   result = (Dali::Vector4 *)&Dali::Color::RED;
23109   jresult = (void *)result;
23110   return jresult;
23111 }
23112
23113
23114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23115   void * jresult ;
23116   Dali::Vector4 *result = 0 ;
23117
23118   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23119   jresult = (void *)result;
23120   return jresult;
23121 }
23122
23123
23124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23125   void * jresult ;
23126   Dali::Vector4 *result = 0 ;
23127
23128   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23129   jresult = (void *)result;
23130   return jresult;
23131 }
23132
23133
23134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23135   void * jresult ;
23136   Dali::Vector4 *result = 0 ;
23137
23138   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23139   jresult = (void *)result;
23140   return jresult;
23141 }
23142
23143
23144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23145   void * jresult ;
23146   Dali::Vector4 *result = 0 ;
23147
23148   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23149   jresult = (void *)result;
23150   return jresult;
23151 }
23152
23153
23154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23155   void * jresult ;
23156   Dali::Vector4 *result = 0 ;
23157
23158   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23159   jresult = (void *)result;
23160   return jresult;
23161 }
23162
23163
23164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23165   void * jresult ;
23166   Dali::Vector4 *result = 0 ;
23167
23168   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23169   jresult = (void *)result;
23170   return jresult;
23171 }
23172
23173
23174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23175   float jresult ;
23176   float result;
23177
23178   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23179   jresult = result;
23180   return jresult;
23181 }
23182
23183
23184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23185   float jresult ;
23186   float result;
23187
23188   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23189   jresult = result;
23190   return jresult;
23191 }
23192
23193
23194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23195   float jresult ;
23196   float result;
23197
23198   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23199   jresult = result;
23200   return jresult;
23201 }
23202
23203
23204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23205   float jresult ;
23206   float result;
23207
23208   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23209   jresult = result;
23210   return jresult;
23211 }
23212
23213
23214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23215   float jresult ;
23216   float result;
23217
23218   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23219   jresult = result;
23220   return jresult;
23221 }
23222
23223
23224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23225   float jresult ;
23226   float result;
23227
23228   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23229   jresult = result;
23230   return jresult;
23231 }
23232
23233
23234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23235   float jresult ;
23236   float result;
23237
23238   result = (float)(float)Dali::Math::PI;
23239   jresult = result;
23240   return jresult;
23241 }
23242
23243
23244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23245   float jresult ;
23246   float result;
23247
23248   result = (float)(float)Dali::Math::PI_2;
23249   jresult = result;
23250   return jresult;
23251 }
23252
23253
23254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23255   float jresult ;
23256   float result;
23257
23258   result = (float)(float)Dali::Math::PI_4;
23259   jresult = result;
23260   return jresult;
23261 }
23262
23263
23264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23265   float jresult ;
23266   float result;
23267
23268   result = (float)(float)Dali::Math::PI_OVER_180;
23269   jresult = result;
23270   return jresult;
23271 }
23272
23273
23274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23275   float jresult ;
23276   float result;
23277
23278   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23279   jresult = result;
23280   return jresult;
23281 }
23282
23283
23284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23285   int jresult ;
23286   Dali::ResizePolicy::Type result;
23287
23288   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23289   jresult = (int)result;
23290   return jresult;
23291 }
23292
23293
23294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23295   unsigned long jresult ;
23296   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23297   Dali::VectorBase::SizeType result;
23298
23299   arg1 = (Dali::VectorBase *)jarg1;
23300   {
23301     try {
23302       result = ((Dali::VectorBase const *)arg1)->Count();
23303     } catch (std::out_of_range& e) {
23304       {
23305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23306       };
23307     } catch (std::exception& e) {
23308       {
23309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23310       };
23311     } catch (Dali::DaliException e) {
23312       {
23313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23314       };
23315     } catch (...) {
23316       {
23317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23318       };
23319     }
23320   }
23321
23322   jresult = (unsigned long)result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23328   unsigned long jresult ;
23329   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23330   Dali::VectorBase::SizeType result;
23331
23332   arg1 = (Dali::VectorBase *)jarg1;
23333   {
23334     try {
23335       result = ((Dali::VectorBase const *)arg1)->Size();
23336     } catch (std::out_of_range& e) {
23337       {
23338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23339       };
23340     } catch (std::exception& e) {
23341       {
23342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23343       };
23344     } catch (Dali::DaliException e) {
23345       {
23346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23347       };
23348     } catch (...) {
23349       {
23350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23351       };
23352     }
23353   }
23354
23355   jresult = (unsigned long)result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23361   unsigned int jresult ;
23362   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23363   bool result;
23364
23365   arg1 = (Dali::VectorBase *)jarg1;
23366   {
23367     try {
23368       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23369     } catch (std::out_of_range& e) {
23370       {
23371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23372       };
23373     } catch (std::exception& e) {
23374       {
23375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23376       };
23377     } catch (Dali::DaliException e) {
23378       {
23379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23380       };
23381     } catch (...) {
23382       {
23383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23384       };
23385     }
23386   }
23387
23388   jresult = result;
23389   return jresult;
23390 }
23391
23392
23393 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23394   unsigned long jresult ;
23395   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23396   Dali::VectorBase::SizeType result;
23397
23398   arg1 = (Dali::VectorBase *)jarg1;
23399   {
23400     try {
23401       result = ((Dali::VectorBase const *)arg1)->Capacity();
23402     } catch (std::out_of_range& e) {
23403       {
23404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23405       };
23406     } catch (std::exception& e) {
23407       {
23408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23409       };
23410     } catch (Dali::DaliException e) {
23411       {
23412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23413       };
23414     } catch (...) {
23415       {
23416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23417       };
23418     }
23419   }
23420
23421   jresult = (unsigned long)result;
23422   return jresult;
23423 }
23424
23425
23426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23427   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23428
23429   arg1 = (Dali::VectorBase *)jarg1;
23430   {
23431     try {
23432       (arg1)->Release();
23433     } catch (std::out_of_range& e) {
23434       {
23435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23436       };
23437     } catch (std::exception& e) {
23438       {
23439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23440       };
23441     } catch (Dali::DaliException e) {
23442       {
23443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23444       };
23445     } catch (...) {
23446       {
23447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23448       };
23449     }
23450   }
23451
23452 }
23453
23454
23455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23456   void * jresult ;
23457   Dali::Image *result = 0 ;
23458
23459   {
23460     try {
23461       result = (Dali::Image *)new Dali::Image();
23462     } catch (std::out_of_range& e) {
23463       {
23464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23465       };
23466     } catch (std::exception& e) {
23467       {
23468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23469       };
23470     } catch (Dali::DaliException e) {
23471       {
23472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23473       };
23474     } catch (...) {
23475       {
23476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23477       };
23478     }
23479   }
23480
23481   jresult = (void *)result;
23482   return jresult;
23483 }
23484
23485
23486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23487   Dali::Image *arg1 = (Dali::Image *) 0 ;
23488
23489   arg1 = (Dali::Image *)jarg1;
23490   {
23491     try {
23492       delete arg1;
23493     } catch (std::out_of_range& e) {
23494       {
23495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23496       };
23497     } catch (std::exception& e) {
23498       {
23499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23500       };
23501     } catch (Dali::DaliException e) {
23502       {
23503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23504       };
23505     } catch (...) {
23506       {
23507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23508       };
23509     }
23510   }
23511
23512 }
23513
23514
23515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23516   void * jresult ;
23517   Dali::Image *arg1 = 0 ;
23518   Dali::Image *result = 0 ;
23519
23520   arg1 = (Dali::Image *)jarg1;
23521   if (!arg1) {
23522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23523     return 0;
23524   }
23525   {
23526     try {
23527       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23528     } catch (std::out_of_range& e) {
23529       {
23530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23531       };
23532     } catch (std::exception& e) {
23533       {
23534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23535       };
23536     } catch (Dali::DaliException e) {
23537       {
23538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23539       };
23540     } catch (...) {
23541       {
23542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23543       };
23544     }
23545   }
23546
23547   jresult = (void *)result;
23548   return jresult;
23549 }
23550
23551
23552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23553   void * jresult ;
23554   Dali::Image *arg1 = (Dali::Image *) 0 ;
23555   Dali::Image *arg2 = 0 ;
23556   Dali::Image *result = 0 ;
23557
23558   arg1 = (Dali::Image *)jarg1;
23559   arg2 = (Dali::Image *)jarg2;
23560   if (!arg2) {
23561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23562     return 0;
23563   }
23564   {
23565     try {
23566       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23582       };
23583     }
23584   }
23585
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23592   void * jresult ;
23593   Dali::BaseHandle arg1 ;
23594   Dali::BaseHandle *argp1 ;
23595   Dali::Image result;
23596
23597   argp1 = (Dali::BaseHandle *)jarg1;
23598   if (!argp1) {
23599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23600     return 0;
23601   }
23602   arg1 = *argp1;
23603   {
23604     try {
23605       result = Dali::Image::DownCast(arg1);
23606     } catch (std::out_of_range& e) {
23607       {
23608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23609       };
23610     } catch (std::exception& e) {
23611       {
23612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23613       };
23614     } catch (Dali::DaliException e) {
23615       {
23616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23617       };
23618     } catch (...) {
23619       {
23620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23621       };
23622     }
23623   }
23624
23625   jresult = new Dali::Image((const Dali::Image &)result);
23626   return jresult;
23627 }
23628
23629
23630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23631   unsigned int jresult ;
23632   Dali::Image *arg1 = (Dali::Image *) 0 ;
23633   unsigned int result;
23634
23635   arg1 = (Dali::Image *)jarg1;
23636   {
23637     try {
23638       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23639     } catch (std::out_of_range& e) {
23640       {
23641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (std::exception& e) {
23644       {
23645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23646       };
23647     } catch (Dali::DaliException e) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23650       };
23651     } catch (...) {
23652       {
23653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23654       };
23655     }
23656   }
23657
23658   jresult = result;
23659   return jresult;
23660 }
23661
23662
23663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23664   unsigned int jresult ;
23665   Dali::Image *arg1 = (Dali::Image *) 0 ;
23666   unsigned int result;
23667
23668   arg1 = (Dali::Image *)jarg1;
23669   {
23670     try {
23671       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23687       };
23688     }
23689   }
23690
23691   jresult = result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23697   void * jresult ;
23698   Dali::Image *arg1 = (Dali::Image *) 0 ;
23699   Dali::Image::ImageSignalType *result = 0 ;
23700
23701   arg1 = (Dali::Image *)jarg1;
23702   {
23703     try {
23704       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23705     } catch (std::out_of_range& e) {
23706       {
23707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23708       };
23709     } catch (std::exception& e) {
23710       {
23711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23712       };
23713     } catch (Dali::DaliException e) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23716       };
23717     } catch (...) {
23718       {
23719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23720       };
23721     }
23722   }
23723
23724   jresult = (void *)result;
23725   return jresult;
23726 }
23727
23728
23729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23730   int jresult ;
23731   Dali::Pixel::Format result;
23732
23733   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23734   jresult = (int)result;
23735   return jresult;
23736 }
23737
23738
23739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23740   int jresult ;
23741   Dali::Pixel::Format result;
23742
23743   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23744   jresult = (int)result;
23745   return jresult;
23746 }
23747
23748
23749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23750   unsigned int jresult ;
23751   Dali::Pixel::Format arg1 ;
23752   bool result;
23753
23754   arg1 = (Dali::Pixel::Format)jarg1;
23755   {
23756     try {
23757       result = (bool)Dali::Pixel::HasAlpha(arg1);
23758     } catch (std::out_of_range& e) {
23759       {
23760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23761       };
23762     } catch (std::exception& e) {
23763       {
23764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23765       };
23766     } catch (Dali::DaliException e) {
23767       {
23768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23769       };
23770     } catch (...) {
23771       {
23772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23773       };
23774     }
23775   }
23776
23777   jresult = result;
23778   return jresult;
23779 }
23780
23781
23782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23783   unsigned int jresult ;
23784   Dali::Pixel::Format arg1 ;
23785   unsigned int result;
23786
23787   arg1 = (Dali::Pixel::Format)jarg1;
23788   {
23789     try {
23790       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23791     } catch (std::out_of_range& e) {
23792       {
23793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23794       };
23795     } catch (std::exception& e) {
23796       {
23797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23798       };
23799     } catch (Dali::DaliException e) {
23800       {
23801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23802       };
23803     } catch (...) {
23804       {
23805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23806       };
23807     }
23808   }
23809
23810   jresult = result;
23811   return jresult;
23812 }
23813
23814
23815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23816   Dali::Pixel::Format arg1 ;
23817   int *arg2 = 0 ;
23818   int *arg3 = 0 ;
23819
23820   arg1 = (Dali::Pixel::Format)jarg1;
23821   arg2 = (int *)jarg2;
23822   if (!arg2) {
23823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23824     return ;
23825   }
23826   arg3 = (int *)jarg3;
23827   if (!arg3) {
23828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23829     return ;
23830   }
23831   {
23832     try {
23833       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23834     } catch (std::out_of_range& e) {
23835       {
23836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23837       };
23838     } catch (std::exception& e) {
23839       {
23840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23841       };
23842     } catch (Dali::DaliException e) {
23843       {
23844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23845       };
23846     } catch (...) {
23847       {
23848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23849       };
23850     }
23851   }
23852
23853 }
23854
23855
23856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23857   void * jresult ;
23858   unsigned char *arg1 = (unsigned char *) 0 ;
23859   unsigned int arg2 ;
23860   unsigned int arg3 ;
23861   unsigned int arg4 ;
23862   Dali::Pixel::Format arg5 ;
23863   Dali::PixelData::ReleaseFunction arg6 ;
23864   Dali::PixelData result;
23865
23866   arg1 = jarg1;
23867   arg2 = (unsigned int)jarg2;
23868   arg3 = (unsigned int)jarg3;
23869   arg4 = (unsigned int)jarg4;
23870   arg5 = (Dali::Pixel::Format)jarg5;
23871   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23872   {
23873     try {
23874       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23875     } catch (std::out_of_range& e) {
23876       {
23877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23878       };
23879     } catch (std::exception& e) {
23880       {
23881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23882       };
23883     } catch (Dali::DaliException e) {
23884       {
23885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23886       };
23887     } catch (...) {
23888       {
23889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23890       };
23891     }
23892   }
23893
23894   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23895
23896
23897   return jresult;
23898 }
23899
23900
23901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23902   void * jresult ;
23903   Dali::PixelData *result = 0 ;
23904
23905   {
23906     try {
23907       result = (Dali::PixelData *)new Dali::PixelData();
23908     } catch (std::out_of_range& e) {
23909       {
23910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23911       };
23912     } catch (std::exception& e) {
23913       {
23914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23915       };
23916     } catch (Dali::DaliException e) {
23917       {
23918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23919       };
23920     } catch (...) {
23921       {
23922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23923       };
23924     }
23925   }
23926
23927   jresult = (void *)result;
23928   return jresult;
23929 }
23930
23931
23932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23933   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23934
23935   arg1 = (Dali::PixelData *)jarg1;
23936   {
23937     try {
23938       delete arg1;
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23946       };
23947     } catch (Dali::DaliException e) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23950       };
23951     } catch (...) {
23952       {
23953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23954       };
23955     }
23956   }
23957
23958 }
23959
23960
23961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23962   void * jresult ;
23963   Dali::PixelData *arg1 = 0 ;
23964   Dali::PixelData *result = 0 ;
23965
23966   arg1 = (Dali::PixelData *)jarg1;
23967   if (!arg1) {
23968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23969     return 0;
23970   }
23971   {
23972     try {
23973       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23974     } catch (std::out_of_range& e) {
23975       {
23976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23977       };
23978     } catch (std::exception& e) {
23979       {
23980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23981       };
23982     } catch (Dali::DaliException e) {
23983       {
23984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23985       };
23986     } catch (...) {
23987       {
23988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23989       };
23990     }
23991   }
23992
23993   jresult = (void *)result;
23994   return jresult;
23995 }
23996
23997
23998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23999   void * jresult ;
24000   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24001   Dali::PixelData *arg2 = 0 ;
24002   Dali::PixelData *result = 0 ;
24003
24004   arg1 = (Dali::PixelData *)jarg1;
24005   arg2 = (Dali::PixelData *)jarg2;
24006   if (!arg2) {
24007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24008     return 0;
24009   }
24010   {
24011     try {
24012       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24028       };
24029     }
24030   }
24031
24032   jresult = (void *)result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24038   unsigned int jresult ;
24039   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24040   unsigned int result;
24041
24042   arg1 = (Dali::PixelData *)jarg1;
24043   {
24044     try {
24045       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24046     } catch (std::out_of_range& e) {
24047       {
24048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24049       };
24050     } catch (std::exception& e) {
24051       {
24052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24053       };
24054     } catch (Dali::DaliException e) {
24055       {
24056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24057       };
24058     } catch (...) {
24059       {
24060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24061       };
24062     }
24063   }
24064
24065   jresult = result;
24066   return jresult;
24067 }
24068
24069
24070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24071   unsigned int jresult ;
24072   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24073   unsigned int result;
24074
24075   arg1 = (Dali::PixelData *)jarg1;
24076   {
24077     try {
24078       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24079     } catch (std::out_of_range& e) {
24080       {
24081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24082       };
24083     } catch (std::exception& e) {
24084       {
24085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (Dali::DaliException e) {
24088       {
24089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24090       };
24091     } catch (...) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24094       };
24095     }
24096   }
24097
24098   jresult = result;
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24104   int jresult ;
24105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24106   Dali::Pixel::Format result;
24107
24108   arg1 = (Dali::PixelData *)jarg1;
24109   {
24110     try {
24111       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24112     } catch (std::out_of_range& e) {
24113       {
24114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24115       };
24116     } catch (std::exception& e) {
24117       {
24118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24119       };
24120     } catch (Dali::DaliException e) {
24121       {
24122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24123       };
24124     } catch (...) {
24125       {
24126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24127       };
24128     }
24129   }
24130
24131   jresult = (int)result;
24132   return jresult;
24133 }
24134
24135
24136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24137   unsigned int jresult ;
24138   unsigned int result;
24139
24140   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24141   jresult = result;
24142   return jresult;
24143 }
24144
24145
24146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24147   unsigned int jresult ;
24148   unsigned int result;
24149
24150   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24151   jresult = result;
24152   return jresult;
24153 }
24154
24155
24156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24157   unsigned int jresult ;
24158   unsigned int result;
24159
24160   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24161   jresult = result;
24162   return jresult;
24163 }
24164
24165
24166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24167   unsigned int jresult ;
24168   unsigned int result;
24169
24170   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24171   jresult = result;
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24177   unsigned int jresult ;
24178   unsigned int result;
24179
24180   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24181   jresult = result;
24182   return jresult;
24183 }
24184
24185
24186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24187   unsigned int jresult ;
24188   unsigned int result;
24189
24190   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24191   jresult = result;
24192   return jresult;
24193 }
24194
24195
24196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24197   void * jresult ;
24198   Dali::TextureType::Type arg1 ;
24199   Dali::Pixel::Format arg2 ;
24200   unsigned int arg3 ;
24201   unsigned int arg4 ;
24202   Dali::Texture result;
24203
24204   arg1 = (Dali::TextureType::Type)jarg1;
24205   arg2 = (Dali::Pixel::Format)jarg2;
24206   arg3 = (unsigned int)jarg3;
24207   arg4 = (unsigned int)jarg4;
24208   {
24209     try {
24210       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24211     } catch (std::out_of_range& e) {
24212       {
24213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24214       };
24215     } catch (std::exception& e) {
24216       {
24217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24218       };
24219     } catch (Dali::DaliException e) {
24220       {
24221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24222       };
24223     } catch (...) {
24224       {
24225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24226       };
24227     }
24228   }
24229
24230   jresult = new Dali::Texture((const Dali::Texture &)result);
24231   return jresult;
24232 }
24233
24234
24235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24236   void * jresult ;
24237   NativeImageInterface *arg1 = 0 ;
24238   Dali::Texture result;
24239
24240   arg1 = (NativeImageInterface *)jarg1;
24241   if (!arg1) {
24242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24243     return 0;
24244   }
24245   {
24246     try {
24247       result = Dali::Texture::New(*arg1);
24248     } catch (std::out_of_range& e) {
24249       {
24250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24251       };
24252     } catch (std::exception& e) {
24253       {
24254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24255       };
24256     } catch (Dali::DaliException e) {
24257       {
24258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24259       };
24260     } catch (...) {
24261       {
24262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24263       };
24264     }
24265   }
24266
24267   jresult = new Dali::Texture((const Dali::Texture &)result);
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24273   void * jresult ;
24274   Dali::Texture *result = 0 ;
24275
24276   {
24277     try {
24278       result = (Dali::Texture *)new Dali::Texture();
24279     } catch (std::out_of_range& e) {
24280       {
24281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24282       };
24283     } catch (std::exception& e) {
24284       {
24285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24286       };
24287     } catch (Dali::DaliException e) {
24288       {
24289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24290       };
24291     } catch (...) {
24292       {
24293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24294       };
24295     }
24296   }
24297
24298   jresult = (void *)result;
24299   return jresult;
24300 }
24301
24302
24303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24304   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24305
24306   arg1 = (Dali::Texture *)jarg1;
24307   {
24308     try {
24309       delete arg1;
24310     } catch (std::out_of_range& e) {
24311       {
24312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24313       };
24314     } catch (std::exception& e) {
24315       {
24316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24317       };
24318     } catch (Dali::DaliException e) {
24319       {
24320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24321       };
24322     } catch (...) {
24323       {
24324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24325       };
24326     }
24327   }
24328
24329 }
24330
24331
24332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24333   void * jresult ;
24334   Dali::Texture *arg1 = 0 ;
24335   Dali::Texture *result = 0 ;
24336
24337   arg1 = (Dali::Texture *)jarg1;
24338   if (!arg1) {
24339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24340     return 0;
24341   }
24342   {
24343     try {
24344       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24345     } catch (std::out_of_range& e) {
24346       {
24347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (std::exception& e) {
24350       {
24351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24352       };
24353     } catch (Dali::DaliException e) {
24354       {
24355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24356       };
24357     } catch (...) {
24358       {
24359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24360       };
24361     }
24362   }
24363
24364   jresult = (void *)result;
24365   return jresult;
24366 }
24367
24368
24369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24370   void * jresult ;
24371   Dali::BaseHandle arg1 ;
24372   Dali::BaseHandle *argp1 ;
24373   Dali::Texture result;
24374
24375   argp1 = (Dali::BaseHandle *)jarg1;
24376   if (!argp1) {
24377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24378     return 0;
24379   }
24380   arg1 = *argp1;
24381   {
24382     try {
24383       result = Dali::Texture::DownCast(arg1);
24384     } catch (std::out_of_range& e) {
24385       {
24386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (std::exception& e) {
24389       {
24390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (Dali::DaliException e) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24395       };
24396     } catch (...) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24399       };
24400     }
24401   }
24402
24403   jresult = new Dali::Texture((const Dali::Texture &)result);
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24409   void * jresult ;
24410   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24411   Dali::Texture *arg2 = 0 ;
24412   Dali::Texture *result = 0 ;
24413
24414   arg1 = (Dali::Texture *)jarg1;
24415   arg2 = (Dali::Texture *)jarg2;
24416   if (!arg2) {
24417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24418     return 0;
24419   }
24420   {
24421     try {
24422       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24423     } catch (std::out_of_range& e) {
24424       {
24425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24426       };
24427     } catch (std::exception& e) {
24428       {
24429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24430       };
24431     } catch (Dali::DaliException e) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24434       };
24435     } catch (...) {
24436       {
24437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24438       };
24439     }
24440   }
24441
24442   jresult = (void *)result;
24443   return jresult;
24444 }
24445
24446
24447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24448   unsigned int jresult ;
24449   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24450   Dali::PixelData arg2 ;
24451   Dali::PixelData *argp2 ;
24452   bool result;
24453
24454   arg1 = (Dali::Texture *)jarg1;
24455   argp2 = (Dali::PixelData *)jarg2;
24456   if (!argp2) {
24457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24458     return 0;
24459   }
24460   arg2 = *argp2;
24461   {
24462     try {
24463       result = (bool)(arg1)->Upload(arg2);
24464     } catch (std::out_of_range& e) {
24465       {
24466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (std::exception& e) {
24469       {
24470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24471       };
24472     } catch (Dali::DaliException e) {
24473       {
24474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24475       };
24476     } catch (...) {
24477       {
24478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24479       };
24480     }
24481   }
24482
24483   jresult = result;
24484   return jresult;
24485 }
24486
24487
24488 SWIGEXPORT 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) {
24489   unsigned int jresult ;
24490   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24491   Dali::PixelData arg2 ;
24492   unsigned int arg3 ;
24493   unsigned int arg4 ;
24494   unsigned int arg5 ;
24495   unsigned int arg6 ;
24496   unsigned int arg7 ;
24497   unsigned int arg8 ;
24498   Dali::PixelData *argp2 ;
24499   bool result;
24500
24501   arg1 = (Dali::Texture *)jarg1;
24502   argp2 = (Dali::PixelData *)jarg2;
24503   if (!argp2) {
24504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24505     return 0;
24506   }
24507   arg2 = *argp2;
24508   arg3 = (unsigned int)jarg3;
24509   arg4 = (unsigned int)jarg4;
24510   arg5 = (unsigned int)jarg5;
24511   arg6 = (unsigned int)jarg6;
24512   arg7 = (unsigned int)jarg7;
24513   arg8 = (unsigned int)jarg8;
24514   {
24515     try {
24516       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24517     } catch (std::out_of_range& e) {
24518       {
24519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24520       };
24521     } catch (std::exception& e) {
24522       {
24523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24524       };
24525     } catch (Dali::DaliException e) {
24526       {
24527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24528       };
24529     } catch (...) {
24530       {
24531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24532       };
24533     }
24534   }
24535
24536   jresult = result;
24537   return jresult;
24538 }
24539
24540
24541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24542   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24543
24544   arg1 = (Dali::Texture *)jarg1;
24545   {
24546     try {
24547       (arg1)->GenerateMipmaps();
24548     } catch (std::out_of_range& e) {
24549       {
24550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24551       };
24552     } catch (std::exception& e) {
24553       {
24554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24555       };
24556     } catch (Dali::DaliException e) {
24557       {
24558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24559       };
24560     } catch (...) {
24561       {
24562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24563       };
24564     }
24565   }
24566
24567 }
24568
24569
24570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24571   unsigned int jresult ;
24572   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24573   unsigned int result;
24574
24575   arg1 = (Dali::Texture *)jarg1;
24576   {
24577     try {
24578       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24579     } catch (std::out_of_range& e) {
24580       {
24581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24582       };
24583     } catch (std::exception& e) {
24584       {
24585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24586       };
24587     } catch (Dali::DaliException e) {
24588       {
24589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24590       };
24591     } catch (...) {
24592       {
24593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24594       };
24595     }
24596   }
24597
24598   jresult = result;
24599   return jresult;
24600 }
24601
24602
24603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24604   unsigned int jresult ;
24605   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24606   unsigned int result;
24607
24608   arg1 = (Dali::Texture *)jarg1;
24609   {
24610     try {
24611       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24612     } catch (std::out_of_range& e) {
24613       {
24614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24615       };
24616     } catch (std::exception& e) {
24617       {
24618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24619       };
24620     } catch (Dali::DaliException e) {
24621       {
24622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24623       };
24624     } catch (...) {
24625       {
24626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24627       };
24628     }
24629   }
24630
24631   jresult = result;
24632   return jresult;
24633 }
24634
24635
24636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24637   void * jresult ;
24638   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24639   Dali::Texture *result = 0 ;
24640
24641   arg1 = (Dali::Internal::Texture *)jarg1;
24642   {
24643     try {
24644       result = (Dali::Texture *)new Dali::Texture(arg1);
24645     } catch (std::out_of_range& e) {
24646       {
24647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24648       };
24649     } catch (std::exception& e) {
24650       {
24651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24652       };
24653     } catch (Dali::DaliException e) {
24654       {
24655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24656       };
24657     } catch (...) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24660       };
24661     }
24662   }
24663
24664   jresult = (void *)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24670   void * jresult ;
24671   Dali::Sampler result;
24672
24673   {
24674     try {
24675       result = Dali::Sampler::New();
24676     } catch (std::out_of_range& e) {
24677       {
24678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24679       };
24680     } catch (std::exception& e) {
24681       {
24682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24683       };
24684     } catch (Dali::DaliException e) {
24685       {
24686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24687       };
24688     } catch (...) {
24689       {
24690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24691       };
24692     }
24693   }
24694
24695   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24696   return jresult;
24697 }
24698
24699
24700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24701   void * jresult ;
24702   Dali::Sampler *result = 0 ;
24703
24704   {
24705     try {
24706       result = (Dali::Sampler *)new Dali::Sampler();
24707     } catch (std::out_of_range& e) {
24708       {
24709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24710       };
24711     } catch (std::exception& e) {
24712       {
24713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (Dali::DaliException e) {
24716       {
24717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24718       };
24719     } catch (...) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24722       };
24723     }
24724   }
24725
24726   jresult = (void *)result;
24727   return jresult;
24728 }
24729
24730
24731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24732   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24733
24734   arg1 = (Dali::Sampler *)jarg1;
24735   {
24736     try {
24737       delete arg1;
24738     } catch (std::out_of_range& e) {
24739       {
24740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24741       };
24742     } catch (std::exception& e) {
24743       {
24744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24745       };
24746     } catch (Dali::DaliException e) {
24747       {
24748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24749       };
24750     } catch (...) {
24751       {
24752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24753       };
24754     }
24755   }
24756
24757 }
24758
24759
24760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24761   void * jresult ;
24762   Dali::Sampler *arg1 = 0 ;
24763   Dali::Sampler *result = 0 ;
24764
24765   arg1 = (Dali::Sampler *)jarg1;
24766   if (!arg1) {
24767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24768     return 0;
24769   }
24770   {
24771     try {
24772       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24773     } catch (std::out_of_range& e) {
24774       {
24775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24776       };
24777     } catch (std::exception& e) {
24778       {
24779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24780       };
24781     } catch (Dali::DaliException e) {
24782       {
24783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24784       };
24785     } catch (...) {
24786       {
24787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24788       };
24789     }
24790   }
24791
24792   jresult = (void *)result;
24793   return jresult;
24794 }
24795
24796
24797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24798   void * jresult ;
24799   Dali::BaseHandle arg1 ;
24800   Dali::BaseHandle *argp1 ;
24801   Dali::Sampler result;
24802
24803   argp1 = (Dali::BaseHandle *)jarg1;
24804   if (!argp1) {
24805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24806     return 0;
24807   }
24808   arg1 = *argp1;
24809   {
24810     try {
24811       result = Dali::Sampler::DownCast(arg1);
24812     } catch (std::out_of_range& e) {
24813       {
24814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24815       };
24816     } catch (std::exception& e) {
24817       {
24818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24819       };
24820     } catch (Dali::DaliException e) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24823       };
24824     } catch (...) {
24825       {
24826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24827       };
24828     }
24829   }
24830
24831   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24832   return jresult;
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24837   void * jresult ;
24838   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24839   Dali::Sampler *arg2 = 0 ;
24840   Dali::Sampler *result = 0 ;
24841
24842   arg1 = (Dali::Sampler *)jarg1;
24843   arg2 = (Dali::Sampler *)jarg2;
24844   if (!arg2) {
24845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24846     return 0;
24847   }
24848   {
24849     try {
24850       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24851     } catch (std::out_of_range& e) {
24852       {
24853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24854       };
24855     } catch (std::exception& e) {
24856       {
24857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24858       };
24859     } catch (Dali::DaliException e) {
24860       {
24861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24862       };
24863     } catch (...) {
24864       {
24865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24866       };
24867     }
24868   }
24869
24870   jresult = (void *)result;
24871   return jresult;
24872 }
24873
24874
24875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24876   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24877   Dali::FilterMode::Type arg2 ;
24878   Dali::FilterMode::Type arg3 ;
24879
24880   arg1 = (Dali::Sampler *)jarg1;
24881   arg2 = (Dali::FilterMode::Type)jarg2;
24882   arg3 = (Dali::FilterMode::Type)jarg3;
24883   {
24884     try {
24885       (arg1)->SetFilterMode(arg2,arg3);
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (Dali::DaliException e) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24897       };
24898     } catch (...) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24901       };
24902     }
24903   }
24904
24905 }
24906
24907
24908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24909   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24910   Dali::WrapMode::Type arg2 ;
24911   Dali::WrapMode::Type arg3 ;
24912
24913   arg1 = (Dali::Sampler *)jarg1;
24914   arg2 = (Dali::WrapMode::Type)jarg2;
24915   arg3 = (Dali::WrapMode::Type)jarg3;
24916   {
24917     try {
24918       (arg1)->SetWrapMode(arg2,arg3);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24926       };
24927     } catch (Dali::DaliException e) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24930       };
24931     } catch (...) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24934       };
24935     }
24936   }
24937
24938 }
24939
24940
24941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24942   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24943   Dali::WrapMode::Type arg2 ;
24944   Dali::WrapMode::Type arg3 ;
24945   Dali::WrapMode::Type arg4 ;
24946
24947   arg1 = (Dali::Sampler *)jarg1;
24948   arg2 = (Dali::WrapMode::Type)jarg2;
24949   arg3 = (Dali::WrapMode::Type)jarg3;
24950   arg4 = (Dali::WrapMode::Type)jarg4;
24951   {
24952     try {
24953       (arg1)->SetWrapMode(arg2,arg3,arg4);
24954     } catch (std::out_of_range& e) {
24955       {
24956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24957       };
24958     } catch (std::exception& e) {
24959       {
24960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (Dali::DaliException e) {
24963       {
24964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24965       };
24966     } catch (...) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24969       };
24970     }
24971   }
24972
24973 }
24974
24975
24976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24977   void * jresult ;
24978   Dali::TextureSet result;
24979
24980   {
24981     try {
24982       result = Dali::TextureSet::New();
24983     } catch (std::out_of_range& e) {
24984       {
24985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24986       };
24987     } catch (std::exception& e) {
24988       {
24989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24990       };
24991     } catch (Dali::DaliException e) {
24992       {
24993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24998       };
24999     }
25000   }
25001
25002   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25003   return jresult;
25004 }
25005
25006
25007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25008   void * jresult ;
25009   Dali::TextureSet *result = 0 ;
25010
25011   {
25012     try {
25013       result = (Dali::TextureSet *)new Dali::TextureSet();
25014     } catch (std::out_of_range& e) {
25015       {
25016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25017       };
25018     } catch (std::exception& e) {
25019       {
25020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25021       };
25022     } catch (Dali::DaliException e) {
25023       {
25024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25029       };
25030     }
25031   }
25032
25033   jresult = (void *)result;
25034   return jresult;
25035 }
25036
25037
25038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25039   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25040
25041   arg1 = (Dali::TextureSet *)jarg1;
25042   {
25043     try {
25044       delete arg1;
25045     } catch (std::out_of_range& e) {
25046       {
25047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25048       };
25049     } catch (std::exception& e) {
25050       {
25051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25052       };
25053     } catch (Dali::DaliException e) {
25054       {
25055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25056       };
25057     } catch (...) {
25058       {
25059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25060       };
25061     }
25062   }
25063
25064 }
25065
25066
25067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25068   void * jresult ;
25069   Dali::TextureSet *arg1 = 0 ;
25070   Dali::TextureSet *result = 0 ;
25071
25072   arg1 = (Dali::TextureSet *)jarg1;
25073   if (!arg1) {
25074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25075     return 0;
25076   }
25077   {
25078     try {
25079       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25080     } catch (std::out_of_range& e) {
25081       {
25082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25083       };
25084     } catch (std::exception& e) {
25085       {
25086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25087       };
25088     } catch (Dali::DaliException e) {
25089       {
25090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25091       };
25092     } catch (...) {
25093       {
25094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25095       };
25096     }
25097   }
25098
25099   jresult = (void *)result;
25100   return jresult;
25101 }
25102
25103
25104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25105   void * jresult ;
25106   Dali::BaseHandle arg1 ;
25107   Dali::BaseHandle *argp1 ;
25108   Dali::TextureSet result;
25109
25110   argp1 = (Dali::BaseHandle *)jarg1;
25111   if (!argp1) {
25112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25113     return 0;
25114   }
25115   arg1 = *argp1;
25116   {
25117     try {
25118       result = Dali::TextureSet::DownCast(arg1);
25119     } catch (std::out_of_range& e) {
25120       {
25121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25122       };
25123     } catch (std::exception& e) {
25124       {
25125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25126       };
25127     } catch (Dali::DaliException e) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25130       };
25131     } catch (...) {
25132       {
25133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25134       };
25135     }
25136   }
25137
25138   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25139   return jresult;
25140 }
25141
25142
25143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25144   void * jresult ;
25145   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25146   Dali::TextureSet *arg2 = 0 ;
25147   Dali::TextureSet *result = 0 ;
25148
25149   arg1 = (Dali::TextureSet *)jarg1;
25150   arg2 = (Dali::TextureSet *)jarg2;
25151   if (!arg2) {
25152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25153     return 0;
25154   }
25155   {
25156     try {
25157       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (Dali::DaliException e) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25169       };
25170     } catch (...) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25173       };
25174     }
25175   }
25176
25177   jresult = (void *)result;
25178   return jresult;
25179 }
25180
25181
25182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25183   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25184   size_t arg2 ;
25185   Dali::Texture arg3 ;
25186   Dali::Texture *argp3 ;
25187
25188   arg1 = (Dali::TextureSet *)jarg1;
25189   arg2 = (size_t)jarg2;
25190   argp3 = (Dali::Texture *)jarg3;
25191   if (!argp3) {
25192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25193     return ;
25194   }
25195   arg3 = *argp3;
25196   {
25197     try {
25198       (arg1)->SetTexture(arg2,arg3);
25199     } catch (std::out_of_range& e) {
25200       {
25201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25202       };
25203     } catch (std::exception& e) {
25204       {
25205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25206       };
25207     } catch (Dali::DaliException e) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25210       };
25211     } catch (...) {
25212       {
25213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25214       };
25215     }
25216   }
25217
25218 }
25219
25220
25221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25222   void * jresult ;
25223   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25224   size_t arg2 ;
25225   Dali::Texture result;
25226
25227   arg1 = (Dali::TextureSet *)jarg1;
25228   arg2 = (size_t)jarg2;
25229   {
25230     try {
25231       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25232     } catch (std::out_of_range& e) {
25233       {
25234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (std::exception& e) {
25237       {
25238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25239       };
25240     } catch (Dali::DaliException e) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25243       };
25244     } catch (...) {
25245       {
25246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25247       };
25248     }
25249   }
25250
25251   jresult = new Dali::Texture((const Dali::Texture &)result);
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25257   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25258   size_t arg2 ;
25259   Dali::Sampler arg3 ;
25260   Dali::Sampler *argp3 ;
25261
25262   arg1 = (Dali::TextureSet *)jarg1;
25263   arg2 = (size_t)jarg2;
25264   argp3 = (Dali::Sampler *)jarg3;
25265   if (!argp3) {
25266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25267     return ;
25268   }
25269   arg3 = *argp3;
25270   {
25271     try {
25272       (arg1)->SetSampler(arg2,arg3);
25273     } catch (std::out_of_range& e) {
25274       {
25275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25276       };
25277     } catch (std::exception& e) {
25278       {
25279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25280       };
25281     } catch (Dali::DaliException e) {
25282       {
25283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25284       };
25285     } catch (...) {
25286       {
25287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25288       };
25289     }
25290   }
25291
25292 }
25293
25294
25295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25296   void * jresult ;
25297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25298   size_t arg2 ;
25299   Dali::Sampler result;
25300
25301   arg1 = (Dali::TextureSet *)jarg1;
25302   arg2 = (size_t)jarg2;
25303   {
25304     try {
25305       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (Dali::DaliException e) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324
25325   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25331   unsigned long jresult ;
25332   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25333   size_t result;
25334
25335   arg1 = (Dali::TextureSet *)jarg1;
25336   {
25337     try {
25338       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25339     } catch (std::out_of_range& e) {
25340       {
25341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25342       };
25343     } catch (std::exception& e) {
25344       {
25345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25346       };
25347     } catch (Dali::DaliException e) {
25348       {
25349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25350       };
25351     } catch (...) {
25352       {
25353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25354       };
25355     }
25356   }
25357
25358   jresult = (unsigned long)result;
25359   return jresult;
25360 }
25361
25362
25363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25364   void * jresult ;
25365   Dali::Property::Map *arg1 = 0 ;
25366   Dali::PropertyBuffer result;
25367
25368   arg1 = (Dali::Property::Map *)jarg1;
25369   if (!arg1) {
25370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25371     return 0;
25372   }
25373   {
25374     try {
25375       result = Dali::PropertyBuffer::New(*arg1);
25376     } catch (std::out_of_range& e) {
25377       {
25378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25379       };
25380     } catch (std::exception& e) {
25381       {
25382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25383       };
25384     } catch (Dali::DaliException e) {
25385       {
25386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25387       };
25388     } catch (...) {
25389       {
25390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25391       };
25392     }
25393   }
25394
25395   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25396   return jresult;
25397 }
25398
25399
25400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25401   void * jresult ;
25402   Dali::PropertyBuffer *result = 0 ;
25403
25404   {
25405     try {
25406       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25422       };
25423     }
25424   }
25425
25426   jresult = (void *)result;
25427   return jresult;
25428 }
25429
25430
25431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25432   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25433
25434   arg1 = (Dali::PropertyBuffer *)jarg1;
25435   {
25436     try {
25437       delete arg1;
25438     } catch (std::out_of_range& e) {
25439       {
25440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25441       };
25442     } catch (std::exception& e) {
25443       {
25444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25445       };
25446     } catch (Dali::DaliException e) {
25447       {
25448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25449       };
25450     } catch (...) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25453       };
25454     }
25455   }
25456
25457 }
25458
25459
25460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25461   void * jresult ;
25462   Dali::PropertyBuffer *arg1 = 0 ;
25463   Dali::PropertyBuffer *result = 0 ;
25464
25465   arg1 = (Dali::PropertyBuffer *)jarg1;
25466   if (!arg1) {
25467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25468     return 0;
25469   }
25470   {
25471     try {
25472       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25473     } catch (std::out_of_range& e) {
25474       {
25475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25476       };
25477     } catch (std::exception& e) {
25478       {
25479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25480       };
25481     } catch (Dali::DaliException e) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25484       };
25485     } catch (...) {
25486       {
25487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25488       };
25489     }
25490   }
25491
25492   jresult = (void *)result;
25493   return jresult;
25494 }
25495
25496
25497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25498   void * jresult ;
25499   Dali::BaseHandle arg1 ;
25500   Dali::BaseHandle *argp1 ;
25501   Dali::PropertyBuffer result;
25502
25503   argp1 = (Dali::BaseHandle *)jarg1;
25504   if (!argp1) {
25505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25506     return 0;
25507   }
25508   arg1 = *argp1;
25509   {
25510     try {
25511       result = Dali::PropertyBuffer::DownCast(arg1);
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25519       };
25520     } catch (Dali::DaliException e) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25523       };
25524     } catch (...) {
25525       {
25526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25527       };
25528     }
25529   }
25530
25531   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25532   return jresult;
25533 }
25534
25535
25536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25537   void * jresult ;
25538   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25539   Dali::PropertyBuffer *arg2 = 0 ;
25540   Dali::PropertyBuffer *result = 0 ;
25541
25542   arg1 = (Dali::PropertyBuffer *)jarg1;
25543   arg2 = (Dali::PropertyBuffer *)jarg2;
25544   if (!arg2) {
25545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25546     return 0;
25547   }
25548   {
25549     try {
25550       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25551     } catch (std::out_of_range& e) {
25552       {
25553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25554       };
25555     } catch (std::exception& e) {
25556       {
25557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25558       };
25559     } catch (Dali::DaliException e) {
25560       {
25561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25562       };
25563     } catch (...) {
25564       {
25565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25566       };
25567     }
25568   }
25569
25570   jresult = (void *)result;
25571   return jresult;
25572 }
25573
25574
25575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25576   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25577   void *arg2 = (void *) 0 ;
25578   std::size_t arg3 ;
25579
25580   arg1 = (Dali::PropertyBuffer *)jarg1;
25581   arg2 = jarg2;
25582   arg3 = (std::size_t)jarg3;
25583   {
25584     try {
25585       (arg1)->SetData((void const *)arg2,arg3);
25586     } catch (std::out_of_range& e) {
25587       {
25588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25589       };
25590     } catch (std::exception& e) {
25591       {
25592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25593       };
25594     } catch (Dali::DaliException e) {
25595       {
25596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25597       };
25598     } catch (...) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25601       };
25602     }
25603   }
25604
25605 }
25606
25607
25608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25609   unsigned long jresult ;
25610   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25611   std::size_t result;
25612
25613   arg1 = (Dali::PropertyBuffer *)jarg1;
25614   {
25615     try {
25616       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25617     } catch (std::out_of_range& e) {
25618       {
25619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25620       };
25621     } catch (std::exception& e) {
25622       {
25623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25624       };
25625     } catch (Dali::DaliException e) {
25626       {
25627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25628       };
25629     } catch (...) {
25630       {
25631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25632       };
25633     }
25634   }
25635
25636   jresult = (unsigned long)result;
25637   return jresult;
25638 }
25639
25640
25641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25642   void * jresult ;
25643   Dali::Geometry result;
25644
25645   {
25646     try {
25647       result = Dali::Geometry::New();
25648     } catch (std::out_of_range& e) {
25649       {
25650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25651       };
25652     } catch (std::exception& e) {
25653       {
25654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25655       };
25656     } catch (Dali::DaliException e) {
25657       {
25658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25659       };
25660     } catch (...) {
25661       {
25662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25663       };
25664     }
25665   }
25666
25667   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25668   return jresult;
25669 }
25670
25671
25672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25673   void * jresult ;
25674   Dali::Geometry *result = 0 ;
25675
25676   {
25677     try {
25678       result = (Dali::Geometry *)new Dali::Geometry();
25679     } catch (std::out_of_range& e) {
25680       {
25681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25682       };
25683     } catch (std::exception& e) {
25684       {
25685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (Dali::DaliException e) {
25688       {
25689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25690       };
25691     } catch (...) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25694       };
25695     }
25696   }
25697
25698   jresult = (void *)result;
25699   return jresult;
25700 }
25701
25702
25703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25704   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25705
25706   arg1 = (Dali::Geometry *)jarg1;
25707   {
25708     try {
25709       delete arg1;
25710     } catch (std::out_of_range& e) {
25711       {
25712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25713       };
25714     } catch (std::exception& e) {
25715       {
25716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25717       };
25718     } catch (Dali::DaliException e) {
25719       {
25720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25721       };
25722     } catch (...) {
25723       {
25724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25725       };
25726     }
25727   }
25728
25729 }
25730
25731
25732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25733   void * jresult ;
25734   Dali::Geometry *arg1 = 0 ;
25735   Dali::Geometry *result = 0 ;
25736
25737   arg1 = (Dali::Geometry *)jarg1;
25738   if (!arg1) {
25739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25740     return 0;
25741   }
25742   {
25743     try {
25744       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25745     } catch (std::out_of_range& e) {
25746       {
25747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25748       };
25749     } catch (std::exception& e) {
25750       {
25751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25752       };
25753     } catch (Dali::DaliException e) {
25754       {
25755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25756       };
25757     } catch (...) {
25758       {
25759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25760       };
25761     }
25762   }
25763
25764   jresult = (void *)result;
25765   return jresult;
25766 }
25767
25768
25769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25770   void * jresult ;
25771   Dali::BaseHandle arg1 ;
25772   Dali::BaseHandle *argp1 ;
25773   Dali::Geometry result;
25774
25775   argp1 = (Dali::BaseHandle *)jarg1;
25776   if (!argp1) {
25777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25778     return 0;
25779   }
25780   arg1 = *argp1;
25781   {
25782     try {
25783       result = Dali::Geometry::DownCast(arg1);
25784     } catch (std::out_of_range& e) {
25785       {
25786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25787       };
25788     } catch (std::exception& e) {
25789       {
25790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25791       };
25792     } catch (Dali::DaliException e) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25799       };
25800     }
25801   }
25802
25803   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25804   return jresult;
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25809   void * jresult ;
25810   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25811   Dali::Geometry *arg2 = 0 ;
25812   Dali::Geometry *result = 0 ;
25813
25814   arg1 = (Dali::Geometry *)jarg1;
25815   arg2 = (Dali::Geometry *)jarg2;
25816   if (!arg2) {
25817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25818     return 0;
25819   }
25820   {
25821     try {
25822       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25823     } catch (std::out_of_range& e) {
25824       {
25825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25826       };
25827     } catch (std::exception& e) {
25828       {
25829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25830       };
25831     } catch (Dali::DaliException e) {
25832       {
25833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25834       };
25835     } catch (...) {
25836       {
25837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25838       };
25839     }
25840   }
25841
25842   jresult = (void *)result;
25843   return jresult;
25844 }
25845
25846
25847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25848   unsigned long jresult ;
25849   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25850   Dali::PropertyBuffer *arg2 = 0 ;
25851   std::size_t result;
25852
25853   arg1 = (Dali::Geometry *)jarg1;
25854   arg2 = (Dali::PropertyBuffer *)jarg2;
25855   if (!arg2) {
25856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25857     return 0;
25858   }
25859   {
25860     try {
25861       result = (arg1)->AddVertexBuffer(*arg2);
25862     } catch (std::out_of_range& e) {
25863       {
25864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (std::exception& e) {
25867       {
25868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25869       };
25870     } catch (Dali::DaliException e) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25873       };
25874     } catch (...) {
25875       {
25876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25877       };
25878     }
25879   }
25880
25881   jresult = (unsigned long)result;
25882   return jresult;
25883 }
25884
25885
25886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25887   unsigned long jresult ;
25888   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25889   std::size_t result;
25890
25891   arg1 = (Dali::Geometry *)jarg1;
25892   {
25893     try {
25894       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25895     } catch (std::out_of_range& e) {
25896       {
25897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (std::exception& e) {
25900       {
25901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (Dali::DaliException e) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25906       };
25907     } catch (...) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25910       };
25911     }
25912   }
25913
25914   jresult = (unsigned long)result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25920   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25921   std::size_t arg2 ;
25922
25923   arg1 = (Dali::Geometry *)jarg1;
25924   arg2 = (std::size_t)jarg2;
25925   {
25926     try {
25927       (arg1)->RemoveVertexBuffer(arg2);
25928     } catch (std::out_of_range& e) {
25929       {
25930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25931       };
25932     } catch (std::exception& e) {
25933       {
25934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25935       };
25936     } catch (Dali::DaliException e) {
25937       {
25938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25939       };
25940     } catch (...) {
25941       {
25942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25943       };
25944     }
25945   }
25946
25947 }
25948
25949
25950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25951   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25952   unsigned short *arg2 = (unsigned short *) 0 ;
25953   size_t arg3 ;
25954
25955   arg1 = (Dali::Geometry *)jarg1;
25956   arg2 = jarg2;
25957   arg3 = (size_t)jarg3;
25958   {
25959     try {
25960       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25961     } catch (std::out_of_range& e) {
25962       {
25963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25964       };
25965     } catch (std::exception& e) {
25966       {
25967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25968       };
25969     } catch (Dali::DaliException e) {
25970       {
25971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25972       };
25973     } catch (...) {
25974       {
25975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25976       };
25977     }
25978   }
25979
25980
25981
25982 }
25983
25984
25985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25986   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25987   Dali::Geometry::Type arg2 ;
25988
25989   arg1 = (Dali::Geometry *)jarg1;
25990   arg2 = (Dali::Geometry::Type)jarg2;
25991   {
25992     try {
25993       (arg1)->SetType(arg2);
25994     } catch (std::out_of_range& e) {
25995       {
25996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25997       };
25998     } catch (std::exception& e) {
25999       {
26000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26001       };
26002     } catch (Dali::DaliException e) {
26003       {
26004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26005       };
26006     } catch (...) {
26007       {
26008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26009       };
26010     }
26011   }
26012
26013 }
26014
26015
26016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26017   int jresult ;
26018   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26019   Dali::Geometry::Type result;
26020
26021   arg1 = (Dali::Geometry *)jarg1;
26022   {
26023     try {
26024       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26025     } catch (std::out_of_range& e) {
26026       {
26027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26028       };
26029     } catch (std::exception& e) {
26030       {
26031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26032       };
26033     } catch (Dali::DaliException e) {
26034       {
26035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26036       };
26037     } catch (...) {
26038       {
26039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26040       };
26041     }
26042   }
26043
26044   jresult = (int)result;
26045   return jresult;
26046 }
26047
26048
26049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26050   void * jresult ;
26051   Dali::Shader::Hint *result = 0 ;
26052
26053   {
26054     try {
26055       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26056     } catch (std::out_of_range& e) {
26057       {
26058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26059       };
26060     } catch (std::exception& e) {
26061       {
26062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26063       };
26064     } catch (Dali::DaliException e) {
26065       {
26066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26067       };
26068     } catch (...) {
26069       {
26070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26071       };
26072     }
26073   }
26074
26075   jresult = (void *)result;
26076   return jresult;
26077 }
26078
26079
26080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26081   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26082
26083   arg1 = (Dali::Shader::Hint *)jarg1;
26084   {
26085     try {
26086       delete arg1;
26087     } catch (std::out_of_range& e) {
26088       {
26089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26090       };
26091     } catch (std::exception& e) {
26092       {
26093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26094       };
26095     } catch (Dali::DaliException e) {
26096       {
26097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26098       };
26099     } catch (...) {
26100       {
26101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26102       };
26103     }
26104   }
26105
26106 }
26107
26108
26109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26110   int jresult ;
26111   int result;
26112
26113   result = (int)Dali::Shader::Property::PROGRAM;
26114   jresult = (int)result;
26115   return jresult;
26116 }
26117
26118
26119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26120   void * jresult ;
26121   Dali::Shader::Property *result = 0 ;
26122
26123   {
26124     try {
26125       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26126     } catch (std::out_of_range& e) {
26127       {
26128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26129       };
26130     } catch (std::exception& e) {
26131       {
26132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26133       };
26134     } catch (Dali::DaliException e) {
26135       {
26136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26137       };
26138     } catch (...) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26141       };
26142     }
26143   }
26144
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26151   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26152
26153   arg1 = (Dali::Shader::Property *)jarg1;
26154   {
26155     try {
26156       delete arg1;
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26164       };
26165     } catch (Dali::DaliException e) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26168       };
26169     } catch (...) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26172       };
26173     }
26174   }
26175
26176 }
26177
26178
26179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26180   void * jresult ;
26181   std::string *arg1 = 0 ;
26182   std::string *arg2 = 0 ;
26183   Dali::Shader::Hint::Value arg3 ;
26184   Dali::Shader result;
26185
26186   if (!jarg1) {
26187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26188     return 0;
26189   }
26190   std::string arg1_str(jarg1);
26191   arg1 = &arg1_str;
26192   if (!jarg2) {
26193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26194     return 0;
26195   }
26196   std::string arg2_str(jarg2);
26197   arg2 = &arg2_str;
26198   arg3 = (Dali::Shader::Hint::Value)jarg3;
26199   {
26200     try {
26201       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = new Dali::Shader((const Dali::Shader &)result);
26222
26223   //argout typemap for const std::string&
26224
26225
26226   //argout typemap for const std::string&
26227
26228   return jresult;
26229 }
26230
26231
26232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26233   void * jresult ;
26234   std::string *arg1 = 0 ;
26235   std::string *arg2 = 0 ;
26236   Dali::Shader result;
26237
26238   if (!jarg1) {
26239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26240     return 0;
26241   }
26242   std::string arg1_str(jarg1);
26243   arg1 = &arg1_str;
26244   if (!jarg2) {
26245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26246     return 0;
26247   }
26248   std::string arg2_str(jarg2);
26249   arg2 = &arg2_str;
26250   {
26251     try {
26252       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26253     } catch (std::out_of_range& e) {
26254       {
26255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26256       };
26257     } catch (std::exception& e) {
26258       {
26259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26260       };
26261     } catch (Dali::DaliException e) {
26262       {
26263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26264       };
26265     } catch (...) {
26266       {
26267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26268       };
26269     }
26270   }
26271
26272   jresult = new Dali::Shader((const Dali::Shader &)result);
26273
26274   //argout typemap for const std::string&
26275
26276
26277   //argout typemap for const std::string&
26278
26279   return jresult;
26280 }
26281
26282
26283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26284   void * jresult ;
26285   Dali::Shader *result = 0 ;
26286
26287   {
26288     try {
26289       result = (Dali::Shader *)new Dali::Shader();
26290     } catch (std::out_of_range& e) {
26291       {
26292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26293       };
26294     } catch (std::exception& e) {
26295       {
26296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26297       };
26298     } catch (Dali::DaliException e) {
26299       {
26300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26301       };
26302     } catch (...) {
26303       {
26304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26305       };
26306     }
26307   }
26308
26309   jresult = (void *)result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26315   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26316
26317   arg1 = (Dali::Shader *)jarg1;
26318   {
26319     try {
26320       delete arg1;
26321     } catch (std::out_of_range& e) {
26322       {
26323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26324       };
26325     } catch (std::exception& e) {
26326       {
26327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26328       };
26329     } catch (Dali::DaliException e) {
26330       {
26331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26332       };
26333     } catch (...) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26336       };
26337     }
26338   }
26339
26340 }
26341
26342
26343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26344   void * jresult ;
26345   Dali::Shader *arg1 = 0 ;
26346   Dali::Shader *result = 0 ;
26347
26348   arg1 = (Dali::Shader *)jarg1;
26349   if (!arg1) {
26350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26351     return 0;
26352   }
26353   {
26354     try {
26355       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26356     } catch (std::out_of_range& e) {
26357       {
26358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26359       };
26360     } catch (std::exception& e) {
26361       {
26362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26363       };
26364     } catch (Dali::DaliException e) {
26365       {
26366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26367       };
26368     } catch (...) {
26369       {
26370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26371       };
26372     }
26373   }
26374
26375   jresult = (void *)result;
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26381   void * jresult ;
26382   Dali::BaseHandle arg1 ;
26383   Dali::BaseHandle *argp1 ;
26384   Dali::Shader result;
26385
26386   argp1 = (Dali::BaseHandle *)jarg1;
26387   if (!argp1) {
26388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26389     return 0;
26390   }
26391   arg1 = *argp1;
26392   {
26393     try {
26394       result = Dali::Shader::DownCast(arg1);
26395     } catch (std::out_of_range& e) {
26396       {
26397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26398       };
26399     } catch (std::exception& e) {
26400       {
26401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26402       };
26403     } catch (Dali::DaliException e) {
26404       {
26405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26406       };
26407     } catch (...) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26410       };
26411     }
26412   }
26413
26414   jresult = new Dali::Shader((const Dali::Shader &)result);
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26420   void * jresult ;
26421   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26422   Dali::Shader *arg2 = 0 ;
26423   Dali::Shader *result = 0 ;
26424
26425   arg1 = (Dali::Shader *)jarg1;
26426   arg2 = (Dali::Shader *)jarg2;
26427   if (!arg2) {
26428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26429     return 0;
26430   }
26431   {
26432     try {
26433       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26434     } catch (std::out_of_range& e) {
26435       {
26436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (std::exception& e) {
26439       {
26440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26441       };
26442     } catch (Dali::DaliException e) {
26443       {
26444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26445       };
26446     } catch (...) {
26447       {
26448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26449       };
26450     }
26451   }
26452
26453   jresult = (void *)result;
26454   return jresult;
26455 }
26456
26457
26458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26459   int jresult ;
26460   int result;
26461
26462   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26463   jresult = (int)result;
26464   return jresult;
26465 }
26466
26467
26468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26469   int jresult ;
26470   int result;
26471
26472   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26473   jresult = (int)result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26479   int jresult ;
26480   int result;
26481
26482   result = (int)Dali::Renderer::Property::BLEND_MODE;
26483   jresult = (int)result;
26484   return jresult;
26485 }
26486
26487
26488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26489   int jresult ;
26490   int result;
26491
26492   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26493   jresult = (int)result;
26494   return jresult;
26495 }
26496
26497
26498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26499   int jresult ;
26500   int result;
26501
26502   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26503   jresult = (int)result;
26504   return jresult;
26505 }
26506
26507
26508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26509   int jresult ;
26510   int result;
26511
26512   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26513   jresult = (int)result;
26514   return jresult;
26515 }
26516
26517
26518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26519   int jresult ;
26520   int result;
26521
26522   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26523   jresult = (int)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26529   int jresult ;
26530   int result;
26531
26532   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26533   jresult = (int)result;
26534   return jresult;
26535 }
26536
26537
26538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26539   int jresult ;
26540   int result;
26541
26542   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26543   jresult = (int)result;
26544   return jresult;
26545 }
26546
26547
26548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26549   int jresult ;
26550   int result;
26551
26552   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26553   jresult = (int)result;
26554   return jresult;
26555 }
26556
26557
26558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26559   int jresult ;
26560   int result;
26561
26562   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26563   jresult = (int)result;
26564   return jresult;
26565 }
26566
26567
26568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26569   int jresult ;
26570   int result;
26571
26572   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26573   jresult = (int)result;
26574   return jresult;
26575 }
26576
26577
26578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26579   int jresult ;
26580   int result;
26581
26582   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26583   jresult = (int)result;
26584   return jresult;
26585 }
26586
26587
26588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26589   int jresult ;
26590   int result;
26591
26592   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26593   jresult = (int)result;
26594   return jresult;
26595 }
26596
26597
26598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26599   int jresult ;
26600   int result;
26601
26602   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26603   jresult = (int)result;
26604   return jresult;
26605 }
26606
26607
26608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26609   int jresult ;
26610   int result;
26611
26612   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26613   jresult = (int)result;
26614   return jresult;
26615 }
26616
26617
26618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26619   int jresult ;
26620   int result;
26621
26622   result = (int)Dali::Renderer::Property::RENDER_MODE;
26623   jresult = (int)result;
26624   return jresult;
26625 }
26626
26627
26628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26629   int jresult ;
26630   int result;
26631
26632   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26633   jresult = (int)result;
26634   return jresult;
26635 }
26636
26637
26638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26639   int jresult ;
26640   int result;
26641
26642   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26643   jresult = (int)result;
26644   return jresult;
26645 }
26646
26647
26648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26649   int jresult ;
26650   int result;
26651
26652   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26653   jresult = (int)result;
26654   return jresult;
26655 }
26656
26657
26658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26659   int jresult ;
26660   int result;
26661
26662   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26663   jresult = (int)result;
26664   return jresult;
26665 }
26666
26667
26668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26669   int jresult ;
26670   int result;
26671
26672   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26673   jresult = (int)result;
26674   return jresult;
26675 }
26676
26677
26678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26679   int jresult ;
26680   int result;
26681
26682   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26683   jresult = (int)result;
26684   return jresult;
26685 }
26686
26687
26688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26689   int jresult ;
26690   int result;
26691
26692   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26693   jresult = (int)result;
26694   return jresult;
26695 }
26696
26697
26698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26699   void * jresult ;
26700   Dali::Renderer::Property *result = 0 ;
26701
26702   {
26703     try {
26704       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26705     } catch (std::out_of_range& e) {
26706       {
26707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26708       };
26709     } catch (std::exception& e) {
26710       {
26711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26712       };
26713     } catch (Dali::DaliException e) {
26714       {
26715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26716       };
26717     } catch (...) {
26718       {
26719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26720       };
26721     }
26722   }
26723
26724   jresult = (void *)result;
26725   return jresult;
26726 }
26727
26728
26729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26730   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26731
26732   arg1 = (Dali::Renderer::Property *)jarg1;
26733   {
26734     try {
26735       delete arg1;
26736     } catch (std::out_of_range& e) {
26737       {
26738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26739       };
26740     } catch (std::exception& e) {
26741       {
26742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26743       };
26744     } catch (Dali::DaliException e) {
26745       {
26746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26747       };
26748     } catch (...) {
26749       {
26750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26751       };
26752     }
26753   }
26754
26755 }
26756
26757
26758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26759   void * jresult ;
26760   Dali::Geometry *arg1 = 0 ;
26761   Dali::Shader *arg2 = 0 ;
26762   Dali::Renderer result;
26763
26764   arg1 = (Dali::Geometry *)jarg1;
26765   if (!arg1) {
26766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26767     return 0;
26768   }
26769   arg2 = (Dali::Shader *)jarg2;
26770   if (!arg2) {
26771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26772     return 0;
26773   }
26774   {
26775     try {
26776       result = Dali::Renderer::New(*arg1,*arg2);
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26802   void * jresult ;
26803   Dali::Renderer *result = 0 ;
26804
26805   {
26806     try {
26807       result = (Dali::Renderer *)new Dali::Renderer();
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 = (void *)result;
26828   return jresult;
26829 }
26830
26831
26832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26833   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26834
26835   arg1 = (Dali::Renderer *)jarg1;
26836   {
26837     try {
26838       delete arg1;
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26846       };
26847     } catch (Dali::DaliException e) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26850       };
26851     } catch (...) {
26852       {
26853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26854       };
26855     }
26856   }
26857
26858 }
26859
26860
26861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26862   void * jresult ;
26863   Dali::Renderer *arg1 = 0 ;
26864   Dali::Renderer *result = 0 ;
26865
26866   arg1 = (Dali::Renderer *)jarg1;
26867   if (!arg1) {
26868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26869     return 0;
26870   }
26871   {
26872     try {
26873       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26874     } catch (std::out_of_range& e) {
26875       {
26876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26877       };
26878     } catch (std::exception& e) {
26879       {
26880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26881       };
26882     } catch (Dali::DaliException e) {
26883       {
26884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26889       };
26890     }
26891   }
26892
26893   jresult = (void *)result;
26894   return jresult;
26895 }
26896
26897
26898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26899   void * jresult ;
26900   Dali::BaseHandle arg1 ;
26901   Dali::BaseHandle *argp1 ;
26902   Dali::Renderer result;
26903
26904   argp1 = (Dali::BaseHandle *)jarg1;
26905   if (!argp1) {
26906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26907     return 0;
26908   }
26909   arg1 = *argp1;
26910   {
26911     try {
26912       result = Dali::Renderer::DownCast(arg1);
26913     } catch (std::out_of_range& e) {
26914       {
26915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26916       };
26917     } catch (std::exception& e) {
26918       {
26919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26920       };
26921     } catch (Dali::DaliException e) {
26922       {
26923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26924       };
26925     } catch (...) {
26926       {
26927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26928       };
26929     }
26930   }
26931
26932   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26933   return jresult;
26934 }
26935
26936
26937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26938   void * jresult ;
26939   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26940   Dali::Renderer *arg2 = 0 ;
26941   Dali::Renderer *result = 0 ;
26942
26943   arg1 = (Dali::Renderer *)jarg1;
26944   arg2 = (Dali::Renderer *)jarg2;
26945   if (!arg2) {
26946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26947     return 0;
26948   }
26949   {
26950     try {
26951       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26952     } catch (std::out_of_range& e) {
26953       {
26954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26955       };
26956     } catch (std::exception& e) {
26957       {
26958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26959       };
26960     } catch (Dali::DaliException e) {
26961       {
26962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26963       };
26964     } catch (...) {
26965       {
26966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26967       };
26968     }
26969   }
26970
26971   jresult = (void *)result;
26972   return jresult;
26973 }
26974
26975
26976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26977   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26978   Dali::Geometry *arg2 = 0 ;
26979
26980   arg1 = (Dali::Renderer *)jarg1;
26981   arg2 = (Dali::Geometry *)jarg2;
26982   if (!arg2) {
26983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26984     return ;
26985   }
26986   {
26987     try {
26988       (arg1)->SetGeometry(*arg2);
26989     } catch (std::out_of_range& e) {
26990       {
26991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26992       };
26993     } catch (std::exception& e) {
26994       {
26995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26996       };
26997     } catch (Dali::DaliException e) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27000       };
27001     } catch (...) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27004       };
27005     }
27006   }
27007
27008 }
27009
27010
27011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27012   void * jresult ;
27013   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27014   Dali::Geometry result;
27015
27016   arg1 = (Dali::Renderer *)jarg1;
27017   {
27018     try {
27019       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27020     } catch (std::out_of_range& e) {
27021       {
27022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27023       };
27024     } catch (std::exception& e) {
27025       {
27026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (Dali::DaliException e) {
27029       {
27030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27031       };
27032     } catch (...) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27035       };
27036     }
27037   }
27038
27039   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27045   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27046   int arg2 ;
27047   int arg3 ;
27048
27049   arg1 = (Dali::Renderer *)jarg1;
27050   arg2 = (int)jarg2;
27051   arg3 = (int)jarg3;
27052   {
27053     try {
27054       (arg1)->SetIndexRange(arg2,arg3);
27055     } catch (std::out_of_range& e) {
27056       {
27057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27058       };
27059     } catch (std::exception& e) {
27060       {
27061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27062       };
27063     } catch (Dali::DaliException e) {
27064       {
27065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27066       };
27067     } catch (...) {
27068       {
27069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27070       };
27071     }
27072   }
27073
27074 }
27075
27076
27077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27078   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27079   Dali::TextureSet *arg2 = 0 ;
27080
27081   arg1 = (Dali::Renderer *)jarg1;
27082   arg2 = (Dali::TextureSet *)jarg2;
27083   if (!arg2) {
27084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27085     return ;
27086   }
27087   {
27088     try {
27089       (arg1)->SetTextures(*arg2);
27090     } catch (std::out_of_range& e) {
27091       {
27092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27093       };
27094     } catch (std::exception& e) {
27095       {
27096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27097       };
27098     } catch (Dali::DaliException e) {
27099       {
27100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27101       };
27102     } catch (...) {
27103       {
27104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27105       };
27106     }
27107   }
27108
27109 }
27110
27111
27112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27113   void * jresult ;
27114   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27115   Dali::TextureSet result;
27116
27117   arg1 = (Dali::Renderer *)jarg1;
27118   {
27119     try {
27120       result = ((Dali::Renderer const *)arg1)->GetTextures();
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27128       };
27129     } catch (Dali::DaliException e) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27132       };
27133     } catch (...) {
27134       {
27135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27136       };
27137     }
27138   }
27139
27140   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27141   return jresult;
27142 }
27143
27144
27145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27146   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27147   Dali::Shader *arg2 = 0 ;
27148
27149   arg1 = (Dali::Renderer *)jarg1;
27150   arg2 = (Dali::Shader *)jarg2;
27151   if (!arg2) {
27152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27153     return ;
27154   }
27155   {
27156     try {
27157       (arg1)->SetShader(*arg2);
27158     } catch (std::out_of_range& e) {
27159       {
27160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27161       };
27162     } catch (std::exception& e) {
27163       {
27164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27165       };
27166     } catch (Dali::DaliException e) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27169       };
27170     } catch (...) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27173       };
27174     }
27175   }
27176
27177 }
27178
27179
27180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27181   void * jresult ;
27182   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27183   Dali::Shader result;
27184
27185   arg1 = (Dali::Renderer *)jarg1;
27186   {
27187     try {
27188       result = ((Dali::Renderer const *)arg1)->GetShader();
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207
27208   jresult = new Dali::Shader((const Dali::Shader &)result);
27209   return jresult;
27210 }
27211
27212
27213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27214   void * jresult ;
27215   Dali::FrameBuffer::Attachment *result = 0 ;
27216
27217   {
27218     try {
27219       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27220     } catch (std::out_of_range& e) {
27221       {
27222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27223       };
27224     } catch (std::exception& e) {
27225       {
27226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27227       };
27228     } catch (Dali::DaliException e) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27231       };
27232     } catch (...) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27235       };
27236     }
27237   }
27238
27239   jresult = (void *)result;
27240   return jresult;
27241 }
27242
27243
27244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27245   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27246
27247   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27248   {
27249     try {
27250       delete arg1;
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27258       };
27259     } catch (Dali::DaliException e) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27262       };
27263     } catch (...) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27266       };
27267     }
27268   }
27269
27270 }
27271
27272
27273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27274   void * jresult ;
27275   unsigned int arg1 ;
27276   unsigned int arg2 ;
27277   unsigned int arg3 ;
27278   Dali::FrameBuffer result;
27279
27280   arg1 = (unsigned int)jarg1;
27281   arg2 = (unsigned int)jarg2;
27282   arg3 = (unsigned int)jarg3;
27283   {
27284     try {
27285       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27286     } catch (std::out_of_range& e) {
27287       {
27288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27289       };
27290     } catch (std::exception& e) {
27291       {
27292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27293       };
27294     } catch (Dali::DaliException e) {
27295       {
27296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27301       };
27302     }
27303   }
27304
27305   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27306   return jresult;
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27311   void * jresult ;
27312   Dali::FrameBuffer *result = 0 ;
27313
27314   {
27315     try {
27316       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
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 = (void *)result;
27337   return jresult;
27338 }
27339
27340
27341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27342   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27343
27344   arg1 = (Dali::FrameBuffer *)jarg1;
27345   {
27346     try {
27347       delete arg1;
27348     } catch (std::out_of_range& e) {
27349       {
27350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27351       };
27352     } catch (std::exception& e) {
27353       {
27354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27355       };
27356     } catch (Dali::DaliException e) {
27357       {
27358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27359       };
27360     } catch (...) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27363       };
27364     }
27365   }
27366
27367 }
27368
27369
27370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27371   void * jresult ;
27372   Dali::FrameBuffer *arg1 = 0 ;
27373   Dali::FrameBuffer *result = 0 ;
27374
27375   arg1 = (Dali::FrameBuffer *)jarg1;
27376   if (!arg1) {
27377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27378     return 0;
27379   }
27380   {
27381     try {
27382       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27383     } catch (std::out_of_range& e) {
27384       {
27385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27386       };
27387     } catch (std::exception& e) {
27388       {
27389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27390       };
27391     } catch (Dali::DaliException e) {
27392       {
27393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27394       };
27395     } catch (...) {
27396       {
27397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27398       };
27399     }
27400   }
27401
27402   jresult = (void *)result;
27403   return jresult;
27404 }
27405
27406
27407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27408   void * jresult ;
27409   Dali::BaseHandle arg1 ;
27410   Dali::BaseHandle *argp1 ;
27411   Dali::FrameBuffer result;
27412
27413   argp1 = (Dali::BaseHandle *)jarg1;
27414   if (!argp1) {
27415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27416     return 0;
27417   }
27418   arg1 = *argp1;
27419   {
27420     try {
27421       result = Dali::FrameBuffer::DownCast(arg1);
27422     } catch (std::out_of_range& e) {
27423       {
27424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27425       };
27426     } catch (std::exception& e) {
27427       {
27428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27429       };
27430     } catch (Dali::DaliException e) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27433       };
27434     } catch (...) {
27435       {
27436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27437       };
27438     }
27439   }
27440
27441   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27442   return jresult;
27443 }
27444
27445
27446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27447   void * jresult ;
27448   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27449   Dali::FrameBuffer *arg2 = 0 ;
27450   Dali::FrameBuffer *result = 0 ;
27451
27452   arg1 = (Dali::FrameBuffer *)jarg1;
27453   arg2 = (Dali::FrameBuffer *)jarg2;
27454   if (!arg2) {
27455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27456     return 0;
27457   }
27458   {
27459     try {
27460       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27461     } catch (std::out_of_range& e) {
27462       {
27463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27464       };
27465     } catch (std::exception& e) {
27466       {
27467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27468       };
27469     } catch (Dali::DaliException e) {
27470       {
27471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27472       };
27473     } catch (...) {
27474       {
27475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27476       };
27477     }
27478   }
27479
27480   jresult = (void *)result;
27481   return jresult;
27482 }
27483
27484
27485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27486   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27487   Dali::Texture *arg2 = 0 ;
27488
27489   arg1 = (Dali::FrameBuffer *)jarg1;
27490   arg2 = (Dali::Texture *)jarg2;
27491   if (!arg2) {
27492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27493     return ;
27494   }
27495   {
27496     try {
27497       (arg1)->AttachColorTexture(*arg2);
27498     } catch (std::out_of_range& e) {
27499       {
27500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27501       };
27502     } catch (std::exception& e) {
27503       {
27504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27505       };
27506     } catch (Dali::DaliException e) {
27507       {
27508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27509       };
27510     } catch (...) {
27511       {
27512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27513       };
27514     }
27515   }
27516
27517 }
27518
27519
27520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27521   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27522   Dali::Texture *arg2 = 0 ;
27523   unsigned int arg3 ;
27524   unsigned int arg4 ;
27525
27526   arg1 = (Dali::FrameBuffer *)jarg1;
27527   arg2 = (Dali::Texture *)jarg2;
27528   if (!arg2) {
27529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27530     return ;
27531   }
27532   arg3 = (unsigned int)jarg3;
27533   arg4 = (unsigned int)jarg4;
27534   {
27535     try {
27536       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27537     } catch (std::out_of_range& e) {
27538       {
27539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27540       };
27541     } catch (std::exception& e) {
27542       {
27543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27544       };
27545     } catch (Dali::DaliException e) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27548       };
27549     } catch (...) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27552       };
27553     }
27554   }
27555
27556 }
27557
27558
27559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27560   void * jresult ;
27561   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27562   Dali::Texture result;
27563
27564   arg1 = (Dali::FrameBuffer *)jarg1;
27565   {
27566     try {
27567       result = (arg1)->GetColorTexture();
27568     } catch (std::out_of_range& e) {
27569       {
27570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27571       };
27572     } catch (std::exception& e) {
27573       {
27574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27575       };
27576     } catch (Dali::DaliException e) {
27577       {
27578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27579       };
27580     } catch (...) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27583       };
27584     }
27585   }
27586
27587   jresult = new Dali::Texture((const Dali::Texture &)result);
27588   return jresult;
27589 }
27590
27591
27592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27593   void * jresult ;
27594   Dali::RenderTaskList *result = 0 ;
27595
27596   {
27597     try {
27598       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
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_DownCast(void * jarg1) {
27624   void * jresult ;
27625   Dali::BaseHandle arg1 ;
27626   Dali::BaseHandle *argp1 ;
27627   Dali::RenderTaskList result;
27628
27629   argp1 = (Dali::BaseHandle *)jarg1;
27630   if (!argp1) {
27631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27632     return 0;
27633   }
27634   arg1 = *argp1;
27635   {
27636     try {
27637       result = Dali::RenderTaskList::DownCast(arg1);
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 = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27658   return jresult;
27659 }
27660
27661
27662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27663   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27664
27665   arg1 = (Dali::RenderTaskList *)jarg1;
27666   {
27667     try {
27668       delete arg1;
27669     } catch (std::out_of_range& e) {
27670       {
27671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27672       };
27673     } catch (std::exception& e) {
27674       {
27675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27676       };
27677     } catch (Dali::DaliException e) {
27678       {
27679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27680       };
27681     } catch (...) {
27682       {
27683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27684       };
27685     }
27686   }
27687
27688 }
27689
27690
27691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27692   void * jresult ;
27693   Dali::RenderTaskList *arg1 = 0 ;
27694   Dali::RenderTaskList *result = 0 ;
27695
27696   arg1 = (Dali::RenderTaskList *)jarg1;
27697   if (!arg1) {
27698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27699     return 0;
27700   }
27701   {
27702     try {
27703       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27704     } catch (std::out_of_range& e) {
27705       {
27706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27707       };
27708     } catch (std::exception& e) {
27709       {
27710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27711       };
27712     } catch (Dali::DaliException e) {
27713       {
27714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27715       };
27716     } catch (...) {
27717       {
27718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27719       };
27720     }
27721   }
27722
27723   jresult = (void *)result;
27724   return jresult;
27725 }
27726
27727
27728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27729   void * jresult ;
27730   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27731   Dali::RenderTaskList *arg2 = 0 ;
27732   Dali::RenderTaskList *result = 0 ;
27733
27734   arg1 = (Dali::RenderTaskList *)jarg1;
27735   arg2 = (Dali::RenderTaskList *)jarg2;
27736   if (!arg2) {
27737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27738     return 0;
27739   }
27740   {
27741     try {
27742       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27743     } catch (std::out_of_range& e) {
27744       {
27745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27746       };
27747     } catch (std::exception& e) {
27748       {
27749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27750       };
27751     } catch (Dali::DaliException e) {
27752       {
27753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27754       };
27755     } catch (...) {
27756       {
27757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27758       };
27759     }
27760   }
27761
27762   jresult = (void *)result;
27763   return jresult;
27764 }
27765
27766
27767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27768   void * jresult ;
27769   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27770   Dali::RenderTask result;
27771
27772   arg1 = (Dali::RenderTaskList *)jarg1;
27773   {
27774     try {
27775       result = (arg1)->CreateTask();
27776     } catch (std::out_of_range& e) {
27777       {
27778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (std::exception& e) {
27781       {
27782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27783       };
27784     } catch (Dali::DaliException e) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27787       };
27788     } catch (...) {
27789       {
27790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27791       };
27792     }
27793   }
27794
27795   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27801   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27802   Dali::RenderTask arg2 ;
27803   Dali::RenderTask *argp2 ;
27804
27805   arg1 = (Dali::RenderTaskList *)jarg1;
27806   argp2 = (Dali::RenderTask *)jarg2;
27807   if (!argp2) {
27808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27809     return ;
27810   }
27811   arg2 = *argp2;
27812   {
27813     try {
27814       (arg1)->RemoveTask(arg2);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27822       };
27823     } catch (Dali::DaliException e) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27830       };
27831     }
27832   }
27833
27834 }
27835
27836
27837 //// ===============================================end part 1 =================
27838
27839 //// ========================= part 2 ===============================
27840
27841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27842   unsigned int jresult ;
27843   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27844   unsigned int result;
27845
27846   arg1 = (Dali::RenderTaskList *)jarg1;
27847   {
27848     try {
27849       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27850     } catch (std::out_of_range& e) {
27851       {
27852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27853       };
27854     } catch (std::exception& e) {
27855       {
27856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27857       };
27858     } catch (Dali::DaliException e) {
27859       {
27860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27861       };
27862     } catch (...) {
27863       {
27864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27865       };
27866     }
27867   }
27868
27869   jresult = result;
27870   return jresult;
27871 }
27872
27873
27874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27875   void * jresult ;
27876   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27877   unsigned int arg2 ;
27878   Dali::RenderTask result;
27879
27880   arg1 = (Dali::RenderTaskList *)jarg1;
27881   arg2 = (unsigned int)jarg2;
27882   {
27883     try {
27884       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27885     } catch (std::out_of_range& e) {
27886       {
27887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27888       };
27889     } catch (std::exception& e) {
27890       {
27891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27892       };
27893     } catch (Dali::DaliException e) {
27894       {
27895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27896       };
27897     } catch (...) {
27898       {
27899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27900       };
27901     }
27902   }
27903
27904   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27905   return jresult;
27906 }
27907
27908
27909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27910   int jresult ;
27911   int result;
27912
27913   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27914   jresult = (int)result;
27915   return jresult;
27916 }
27917
27918
27919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27920   int jresult ;
27921   int result;
27922
27923   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27924   jresult = (int)result;
27925   return jresult;
27926 }
27927
27928
27929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27930   int jresult ;
27931   int result;
27932
27933   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27934   jresult = (int)result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27940   int jresult ;
27941   int result;
27942
27943   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27944   jresult = (int)result;
27945   return jresult;
27946 }
27947
27948
27949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27950   void * jresult ;
27951   Dali::RenderTask::Property *result = 0 ;
27952
27953   {
27954     try {
27955       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27956     } catch (std::out_of_range& e) {
27957       {
27958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (std::exception& e) {
27961       {
27962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27963       };
27964     } catch (Dali::DaliException e) {
27965       {
27966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27967       };
27968     } catch (...) {
27969       {
27970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27971       };
27972     }
27973   }
27974
27975   jresult = (void *)result;
27976   return jresult;
27977 }
27978
27979
27980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27981   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27982
27983   arg1 = (Dali::RenderTask::Property *)jarg1;
27984   {
27985     try {
27986       delete arg1;
27987     } catch (std::out_of_range& e) {
27988       {
27989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27990       };
27991     } catch (std::exception& e) {
27992       {
27993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27994       };
27995     } catch (Dali::DaliException e) {
27996       {
27997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27998       };
27999     } catch (...) {
28000       {
28001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28002       };
28003     }
28004   }
28005
28006 }
28007
28008
28009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28010   void * jresult ;
28011   bool (*result)(Dali::Vector2 &) = 0 ;
28012
28013   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28014   jresult = (void *)result;
28015   return jresult;
28016 }
28017
28018
28019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28020   void * jresult ;
28021   bool (*result)(Dali::Vector2 &) = 0 ;
28022
28023   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28024   jresult = (void *)result;
28025   return jresult;
28026 }
28027
28028
28029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28030   unsigned int jresult ;
28031   bool result;
28032
28033   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28034   jresult = result;
28035   return jresult;
28036 }
28037
28038
28039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28040   unsigned int jresult ;
28041   bool result;
28042
28043   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28044   jresult = result;
28045   return jresult;
28046 }
28047
28048
28049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28050   void * jresult ;
28051   Dali::Vector4 *result = 0 ;
28052
28053   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28060   unsigned int jresult ;
28061   bool result;
28062
28063   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28064   jresult = result;
28065   return jresult;
28066 }
28067
28068
28069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28070   unsigned int jresult ;
28071   bool result;
28072
28073   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28074   jresult = result;
28075   return jresult;
28076 }
28077
28078
28079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28080   unsigned int jresult ;
28081   unsigned int result;
28082
28083   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28084   jresult = result;
28085   return jresult;
28086 }
28087
28088
28089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28090   void * jresult ;
28091   Dali::RenderTask *result = 0 ;
28092
28093   {
28094     try {
28095       result = (Dali::RenderTask *)new Dali::RenderTask();
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_DownCast(void * jarg1) {
28121   void * jresult ;
28122   Dali::BaseHandle arg1 ;
28123   Dali::BaseHandle *argp1 ;
28124   Dali::RenderTask result;
28125
28126   argp1 = (Dali::BaseHandle *)jarg1;
28127   if (!argp1) {
28128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28129     return 0;
28130   }
28131   arg1 = *argp1;
28132   {
28133     try {
28134       result = Dali::RenderTask::DownCast(arg1);
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 = new Dali::RenderTask((const Dali::RenderTask &)result);
28155   return jresult;
28156 }
28157
28158
28159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28160   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28161
28162   arg1 = (Dali::RenderTask *)jarg1;
28163   {
28164     try {
28165       delete arg1;
28166     } catch (std::out_of_range& e) {
28167       {
28168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28169       };
28170     } catch (std::exception& e) {
28171       {
28172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28173       };
28174     } catch (Dali::DaliException e) {
28175       {
28176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28177       };
28178     } catch (...) {
28179       {
28180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28181       };
28182     }
28183   }
28184
28185 }
28186
28187
28188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28189   void * jresult ;
28190   Dali::RenderTask *arg1 = 0 ;
28191   Dali::RenderTask *result = 0 ;
28192
28193   arg1 = (Dali::RenderTask *)jarg1;
28194   if (!arg1) {
28195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28196     return 0;
28197   }
28198   {
28199     try {
28200       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28201     } catch (std::out_of_range& e) {
28202       {
28203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28204       };
28205     } catch (std::exception& e) {
28206       {
28207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28208       };
28209     } catch (Dali::DaliException e) {
28210       {
28211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28212       };
28213     } catch (...) {
28214       {
28215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28216       };
28217     }
28218   }
28219
28220   jresult = (void *)result;
28221   return jresult;
28222 }
28223
28224
28225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28226   void * jresult ;
28227   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28228   Dali::RenderTask *arg2 = 0 ;
28229   Dali::RenderTask *result = 0 ;
28230
28231   arg1 = (Dali::RenderTask *)jarg1;
28232   arg2 = (Dali::RenderTask *)jarg2;
28233   if (!arg2) {
28234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28235     return 0;
28236   }
28237   {
28238     try {
28239       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28240     } catch (std::out_of_range& e) {
28241       {
28242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28243       };
28244     } catch (std::exception& e) {
28245       {
28246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28247       };
28248     } catch (Dali::DaliException e) {
28249       {
28250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28251       };
28252     } catch (...) {
28253       {
28254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28255       };
28256     }
28257   }
28258
28259   jresult = (void *)result;
28260   return jresult;
28261 }
28262
28263
28264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28266   Dali::Actor arg2 ;
28267   Dali::Actor *argp2 ;
28268
28269   arg1 = (Dali::RenderTask *)jarg1;
28270   argp2 = (Dali::Actor *)jarg2;
28271   if (!argp2) {
28272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28273     return ;
28274   }
28275   arg2 = *argp2;
28276   {
28277     try {
28278       (arg1)->SetSourceActor(arg2);
28279     } catch (std::out_of_range& e) {
28280       {
28281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28282       };
28283     } catch (std::exception& e) {
28284       {
28285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28286       };
28287     } catch (Dali::DaliException e) {
28288       {
28289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28290       };
28291     } catch (...) {
28292       {
28293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28294       };
28295     }
28296   }
28297
28298 }
28299
28300
28301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28302   void * jresult ;
28303   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28304   Dali::Actor result;
28305
28306   arg1 = (Dali::RenderTask *)jarg1;
28307   {
28308     try {
28309       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28310     } catch (std::out_of_range& e) {
28311       {
28312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28313       };
28314     } catch (std::exception& e) {
28315       {
28316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (Dali::DaliException e) {
28319       {
28320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28325       };
28326     }
28327   }
28328
28329   jresult = new Dali::Actor((const Dali::Actor &)result);
28330   return jresult;
28331 }
28332
28333
28334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28335   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28336   bool arg2 ;
28337
28338   arg1 = (Dali::RenderTask *)jarg1;
28339   arg2 = jarg2 ? true : false;
28340   {
28341     try {
28342       (arg1)->SetExclusive(arg2);
28343     } catch (std::out_of_range& e) {
28344       {
28345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28346       };
28347     } catch (std::exception& e) {
28348       {
28349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28350       };
28351     } catch (Dali::DaliException e) {
28352       {
28353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28354       };
28355     } catch (...) {
28356       {
28357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28358       };
28359     }
28360   }
28361
28362 }
28363
28364
28365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28366   unsigned int jresult ;
28367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28368   bool result;
28369
28370   arg1 = (Dali::RenderTask *)jarg1;
28371   {
28372     try {
28373       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28374     } catch (std::out_of_range& e) {
28375       {
28376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28377       };
28378     } catch (std::exception& e) {
28379       {
28380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28381       };
28382     } catch (Dali::DaliException e) {
28383       {
28384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28385       };
28386     } catch (...) {
28387       {
28388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28389       };
28390     }
28391   }
28392
28393   jresult = result;
28394   return jresult;
28395 }
28396
28397
28398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28399   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28400   bool arg2 ;
28401
28402   arg1 = (Dali::RenderTask *)jarg1;
28403   arg2 = jarg2 ? true : false;
28404   {
28405     try {
28406       (arg1)->SetInputEnabled(arg2);
28407     } catch (std::out_of_range& e) {
28408       {
28409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28410       };
28411     } catch (std::exception& e) {
28412       {
28413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28414       };
28415     } catch (Dali::DaliException e) {
28416       {
28417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28418       };
28419     } catch (...) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28422       };
28423     }
28424   }
28425
28426 }
28427
28428
28429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28430   unsigned int jresult ;
28431   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28432   bool result;
28433
28434   arg1 = (Dali::RenderTask *)jarg1;
28435   {
28436     try {
28437       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28438     } catch (std::out_of_range& e) {
28439       {
28440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28441       };
28442     } catch (std::exception& e) {
28443       {
28444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (Dali::DaliException e) {
28447       {
28448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28449       };
28450     } catch (...) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28453       };
28454     }
28455   }
28456
28457   jresult = result;
28458   return jresult;
28459 }
28460
28461
28462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28463   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28464   Dali::CameraActor arg2 ;
28465   Dali::CameraActor *argp2 ;
28466
28467   arg1 = (Dali::RenderTask *)jarg1;
28468   argp2 = (Dali::CameraActor *)jarg2;
28469   if (!argp2) {
28470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28471     return ;
28472   }
28473   arg2 = *argp2;
28474   {
28475     try {
28476       (arg1)->SetCameraActor(arg2);
28477     } catch (std::out_of_range& e) {
28478       {
28479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28480       };
28481     } catch (std::exception& e) {
28482       {
28483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (Dali::DaliException e) {
28486       {
28487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28488       };
28489     } catch (...) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28492       };
28493     }
28494   }
28495
28496 }
28497
28498
28499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28500   void * jresult ;
28501   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28502   Dali::CameraActor result;
28503
28504   arg1 = (Dali::RenderTask *)jarg1;
28505   {
28506     try {
28507       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28508     } catch (std::out_of_range& e) {
28509       {
28510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28511       };
28512     } catch (std::exception& e) {
28513       {
28514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (Dali::DaliException e) {
28517       {
28518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28519       };
28520     } catch (...) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28523       };
28524     }
28525   }
28526
28527   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28528   return jresult;
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28533   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28534   Dali::FrameBufferImage arg2 ;
28535   Dali::FrameBufferImage *argp2 ;
28536
28537   arg1 = (Dali::RenderTask *)jarg1;
28538   argp2 = (Dali::FrameBufferImage *)jarg2;
28539   if (!argp2) {
28540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28541     return ;
28542   }
28543   arg2 = *argp2;
28544   {
28545     try {
28546       (arg1)->SetTargetFrameBuffer(arg2);
28547     } catch (std::out_of_range& e) {
28548       {
28549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28550       };
28551     } catch (std::exception& e) {
28552       {
28553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28554       };
28555     } catch (Dali::DaliException e) {
28556       {
28557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28558       };
28559     } catch (...) {
28560       {
28561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28562       };
28563     }
28564   }
28565
28566 }
28567
28568
28569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28570   void * jresult ;
28571   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28572   Dali::FrameBufferImage result;
28573
28574   arg1 = (Dali::RenderTask *)jarg1;
28575   {
28576     try {
28577       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28578     } catch (std::out_of_range& e) {
28579       {
28580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28581       };
28582     } catch (std::exception& e) {
28583       {
28584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28585       };
28586     } catch (Dali::DaliException e) {
28587       {
28588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28589       };
28590     } catch (...) {
28591       {
28592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28593       };
28594     }
28595   }
28596
28597   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28598   return jresult;
28599 }
28600
28601
28602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28603   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28604   Dali::FrameBuffer arg2 ;
28605   Dali::FrameBuffer *argp2 ;
28606
28607   arg1 = (Dali::RenderTask *)jarg1;
28608   argp2 = (Dali::FrameBuffer *)jarg2;
28609   if (!argp2) {
28610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28611     return ;
28612   }
28613   arg2 = *argp2;
28614   {
28615     try {
28616       (arg1)->SetFrameBuffer(arg2);
28617     } catch (std::out_of_range& e) {
28618       {
28619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28620       };
28621     } catch (std::exception& e) {
28622       {
28623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28624       };
28625     } catch (Dali::DaliException e) {
28626       {
28627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28628       };
28629     } catch (...) {
28630       {
28631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28632       };
28633     }
28634   }
28635
28636 }
28637
28638
28639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28640   void * jresult ;
28641   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28642   Dali::FrameBuffer result;
28643
28644   arg1 = (Dali::RenderTask *)jarg1;
28645   {
28646     try {
28647       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28648     } catch (std::out_of_range& e) {
28649       {
28650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28651       };
28652     } catch (std::exception& e) {
28653       {
28654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28655       };
28656     } catch (Dali::DaliException e) {
28657       {
28658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28659       };
28660     } catch (...) {
28661       {
28662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28663       };
28664     }
28665   }
28666
28667   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28668   return jresult;
28669 }
28670
28671
28672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28674   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28675
28676   arg1 = (Dali::RenderTask *)jarg1;
28677   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28678   {
28679     try {
28680       (arg1)->SetScreenToFrameBufferFunction(arg2);
28681     } catch (std::out_of_range& e) {
28682       {
28683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28684       };
28685     } catch (std::exception& e) {
28686       {
28687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28688       };
28689     } catch (Dali::DaliException e) {
28690       {
28691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28692       };
28693     } catch (...) {
28694       {
28695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28696       };
28697     }
28698   }
28699
28700 }
28701
28702
28703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28704   void * jresult ;
28705   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28706   Dali::RenderTask::ScreenToFrameBufferFunction result;
28707
28708   arg1 = (Dali::RenderTask *)jarg1;
28709   {
28710     try {
28711       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28712     } catch (std::out_of_range& e) {
28713       {
28714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28715       };
28716     } catch (std::exception& e) {
28717       {
28718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28719       };
28720     } catch (Dali::DaliException e) {
28721       {
28722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28723       };
28724     } catch (...) {
28725       {
28726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28727       };
28728     }
28729   }
28730
28731   jresult = (void *)result;
28732   return jresult;
28733 }
28734
28735
28736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28737   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28738   Dali::Actor arg2 ;
28739   Dali::Actor *argp2 ;
28740
28741   arg1 = (Dali::RenderTask *)jarg1;
28742   argp2 = (Dali::Actor *)jarg2;
28743   if (!argp2) {
28744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28745     return ;
28746   }
28747   arg2 = *argp2;
28748   {
28749     try {
28750       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28751     } catch (std::out_of_range& e) {
28752       {
28753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28754       };
28755     } catch (std::exception& e) {
28756       {
28757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28758       };
28759     } catch (Dali::DaliException e) {
28760       {
28761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28762       };
28763     } catch (...) {
28764       {
28765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28766       };
28767     }
28768   }
28769
28770 }
28771
28772
28773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28774   void * jresult ;
28775   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28776   Dali::Actor result;
28777
28778   arg1 = (Dali::RenderTask *)jarg1;
28779   {
28780     try {
28781       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28782     } catch (std::out_of_range& e) {
28783       {
28784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28785       };
28786     } catch (std::exception& e) {
28787       {
28788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28789       };
28790     } catch (Dali::DaliException e) {
28791       {
28792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28793       };
28794     } catch (...) {
28795       {
28796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28797       };
28798     }
28799   }
28800
28801   jresult = new Dali::Actor((const Dali::Actor &)result);
28802   return jresult;
28803 }
28804
28805
28806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28807   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28808   Dali::Vector2 arg2 ;
28809   Dali::Vector2 *argp2 ;
28810
28811   arg1 = (Dali::RenderTask *)jarg1;
28812   argp2 = (Dali::Vector2 *)jarg2;
28813   if (!argp2) {
28814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28815     return ;
28816   }
28817   arg2 = *argp2;
28818   {
28819     try {
28820       (arg1)->SetViewportPosition(arg2);
28821     } catch (std::out_of_range& e) {
28822       {
28823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28824       };
28825     } catch (std::exception& e) {
28826       {
28827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28828       };
28829     } catch (Dali::DaliException e) {
28830       {
28831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28832       };
28833     } catch (...) {
28834       {
28835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28836       };
28837     }
28838   }
28839
28840 }
28841
28842
28843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28844   void * jresult ;
28845   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28846   Dali::Vector2 result;
28847
28848   arg1 = (Dali::RenderTask *)jarg1;
28849   {
28850     try {
28851       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28852     } catch (std::out_of_range& e) {
28853       {
28854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28855       };
28856     } catch (std::exception& e) {
28857       {
28858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28859       };
28860     } catch (Dali::DaliException e) {
28861       {
28862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28863       };
28864     } catch (...) {
28865       {
28866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28867       };
28868     }
28869   }
28870
28871   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28872   return jresult;
28873 }
28874
28875
28876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28877   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28878   Dali::Vector2 arg2 ;
28879   Dali::Vector2 *argp2 ;
28880
28881   arg1 = (Dali::RenderTask *)jarg1;
28882   argp2 = (Dali::Vector2 *)jarg2;
28883   if (!argp2) {
28884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28885     return ;
28886   }
28887   arg2 = *argp2;
28888   {
28889     try {
28890       (arg1)->SetViewportSize(arg2);
28891     } catch (std::out_of_range& e) {
28892       {
28893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28894       };
28895     } catch (std::exception& e) {
28896       {
28897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28898       };
28899     } catch (Dali::DaliException e) {
28900       {
28901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28902       };
28903     } catch (...) {
28904       {
28905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28906       };
28907     }
28908   }
28909
28910 }
28911
28912
28913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28914   void * jresult ;
28915   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28916   Dali::Vector2 result;
28917
28918   arg1 = (Dali::RenderTask *)jarg1;
28919   {
28920     try {
28921       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28922     } catch (std::out_of_range& e) {
28923       {
28924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28925       };
28926     } catch (std::exception& e) {
28927       {
28928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28929       };
28930     } catch (Dali::DaliException e) {
28931       {
28932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28933       };
28934     } catch (...) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28937       };
28938     }
28939   }
28940
28941   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28942   return jresult;
28943 }
28944
28945
28946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28947   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28948   Dali::Viewport arg2 ;
28949   Dali::Viewport *argp2 ;
28950
28951   arg1 = (Dali::RenderTask *)jarg1;
28952   argp2 = (Dali::Viewport *)jarg2;
28953   if (!argp2) {
28954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28955     return ;
28956   }
28957   arg2 = *argp2;
28958   {
28959     try {
28960       (arg1)->SetViewport(arg2);
28961     } catch (std::out_of_range& e) {
28962       {
28963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28964       };
28965     } catch (std::exception& e) {
28966       {
28967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28968       };
28969     } catch (Dali::DaliException e) {
28970       {
28971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28972       };
28973     } catch (...) {
28974       {
28975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28976       };
28977     }
28978   }
28979
28980 }
28981
28982
28983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28984   void * jresult ;
28985   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28986   Dali::Viewport result;
28987
28988   arg1 = (Dali::RenderTask *)jarg1;
28989   {
28990     try {
28991       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28992     } catch (std::out_of_range& e) {
28993       {
28994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28995       };
28996     } catch (std::exception& e) {
28997       {
28998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28999       };
29000     } catch (Dali::DaliException e) {
29001       {
29002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29003       };
29004     } catch (...) {
29005       {
29006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29007       };
29008     }
29009   }
29010
29011   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29012   return jresult;
29013 }
29014
29015
29016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29017   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29018   Dali::Vector4 *arg2 = 0 ;
29019
29020   arg1 = (Dali::RenderTask *)jarg1;
29021   arg2 = (Dali::Vector4 *)jarg2;
29022   if (!arg2) {
29023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29024     return ;
29025   }
29026   {
29027     try {
29028       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29029     } catch (std::out_of_range& e) {
29030       {
29031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29032       };
29033     } catch (std::exception& e) {
29034       {
29035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (Dali::DaliException e) {
29038       {
29039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29040       };
29041     } catch (...) {
29042       {
29043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29044       };
29045     }
29046   }
29047
29048 }
29049
29050
29051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29052   void * jresult ;
29053   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29054   Dali::Vector4 result;
29055
29056   arg1 = (Dali::RenderTask *)jarg1;
29057   {
29058     try {
29059       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29060     } catch (std::out_of_range& e) {
29061       {
29062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29063       };
29064     } catch (std::exception& e) {
29065       {
29066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (Dali::DaliException e) {
29069       {
29070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29071       };
29072     } catch (...) {
29073       {
29074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29075       };
29076     }
29077   }
29078
29079   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29085   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29086   bool arg2 ;
29087
29088   arg1 = (Dali::RenderTask *)jarg1;
29089   arg2 = jarg2 ? true : false;
29090   {
29091     try {
29092       (arg1)->SetClearEnabled(arg2);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29100       };
29101     } catch (Dali::DaliException e) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29104       };
29105     } catch (...) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29108       };
29109     }
29110   }
29111
29112 }
29113
29114
29115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29116   unsigned int jresult ;
29117   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29118   bool result;
29119
29120   arg1 = (Dali::RenderTask *)jarg1;
29121   {
29122     try {
29123       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29124     } catch (std::out_of_range& e) {
29125       {
29126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (std::exception& e) {
29129       {
29130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (Dali::DaliException e) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29135       };
29136     } catch (...) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29139       };
29140     }
29141   }
29142
29143   jresult = result;
29144   return jresult;
29145 }
29146
29147
29148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29149   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29150   bool arg2 ;
29151
29152   arg1 = (Dali::RenderTask *)jarg1;
29153   arg2 = jarg2 ? true : false;
29154   {
29155     try {
29156       (arg1)->SetCullMode(arg2);
29157     } catch (std::out_of_range& e) {
29158       {
29159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29160       };
29161     } catch (std::exception& e) {
29162       {
29163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29164       };
29165     } catch (Dali::DaliException e) {
29166       {
29167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29168       };
29169     } catch (...) {
29170       {
29171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29172       };
29173     }
29174   }
29175
29176 }
29177
29178
29179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29180   unsigned int jresult ;
29181   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29182   bool result;
29183
29184   arg1 = (Dali::RenderTask *)jarg1;
29185   {
29186     try {
29187       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29188     } catch (std::out_of_range& e) {
29189       {
29190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29191       };
29192     } catch (std::exception& e) {
29193       {
29194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (Dali::DaliException e) {
29197       {
29198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29199       };
29200     } catch (...) {
29201       {
29202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29203       };
29204     }
29205   }
29206
29207   jresult = result;
29208   return jresult;
29209 }
29210
29211
29212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29213   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29214   unsigned int arg2 ;
29215
29216   arg1 = (Dali::RenderTask *)jarg1;
29217   arg2 = (unsigned int)jarg2;
29218   {
29219     try {
29220       (arg1)->SetRefreshRate(arg2);
29221     } catch (std::out_of_range& e) {
29222       {
29223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29224       };
29225     } catch (std::exception& e) {
29226       {
29227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29228       };
29229     } catch (Dali::DaliException e) {
29230       {
29231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29232       };
29233     } catch (...) {
29234       {
29235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29236       };
29237     }
29238   }
29239
29240 }
29241
29242
29243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29244   unsigned int jresult ;
29245   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29246   unsigned int result;
29247
29248   arg1 = (Dali::RenderTask *)jarg1;
29249   {
29250     try {
29251       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29252     } catch (std::out_of_range& e) {
29253       {
29254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29255       };
29256     } catch (std::exception& e) {
29257       {
29258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (Dali::DaliException e) {
29261       {
29262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29263       };
29264     } catch (...) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29267       };
29268     }
29269   }
29270
29271   jresult = result;
29272   return jresult;
29273 }
29274
29275
29276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29277   unsigned int jresult ;
29278   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29279   Dali::Vector3 *arg2 = 0 ;
29280   float *arg3 = 0 ;
29281   float *arg4 = 0 ;
29282   bool result;
29283
29284   arg1 = (Dali::RenderTask *)jarg1;
29285   arg2 = (Dali::Vector3 *)jarg2;
29286   if (!arg2) {
29287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29288     return 0;
29289   }
29290   arg3 = (float *)jarg3;
29291   arg4 = (float *)jarg4;
29292   {
29293     try {
29294       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29295     } catch (std::out_of_range& e) {
29296       {
29297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29298       };
29299     } catch (std::exception& e) {
29300       {
29301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29302       };
29303     } catch (Dali::DaliException e) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29306       };
29307     } catch (...) {
29308       {
29309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29310       };
29311     }
29312   }
29313
29314   jresult = result;
29315   return jresult;
29316 }
29317
29318
29319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29320   unsigned int jresult ;
29321   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29322   Dali::Actor arg2 ;
29323   float arg3 ;
29324   float arg4 ;
29325   float *arg5 = 0 ;
29326   float *arg6 = 0 ;
29327   Dali::Actor *argp2 ;
29328   bool result;
29329
29330   arg1 = (Dali::RenderTask *)jarg1;
29331   argp2 = (Dali::Actor *)jarg2;
29332   if (!argp2) {
29333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29334     return 0;
29335   }
29336   arg2 = *argp2;
29337   arg3 = (float)jarg3;
29338   arg4 = (float)jarg4;
29339   arg5 = (float *)jarg5;
29340   arg6 = (float *)jarg6;
29341   {
29342     try {
29343       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29344     } catch (std::out_of_range& e) {
29345       {
29346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29347       };
29348     } catch (std::exception& e) {
29349       {
29350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29351       };
29352     } catch (Dali::DaliException e) {
29353       {
29354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29355       };
29356     } catch (...) {
29357       {
29358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29359       };
29360     }
29361   }
29362
29363   jresult = result;
29364   return jresult;
29365 }
29366
29367
29368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29369   void * jresult ;
29370   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29371   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29372
29373   arg1 = (Dali::RenderTask *)jarg1;
29374   {
29375     try {
29376       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29377     } catch (std::out_of_range& e) {
29378       {
29379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29380       };
29381     } catch (std::exception& e) {
29382       {
29383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (Dali::DaliException e) {
29386       {
29387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395
29396   jresult = (void *)result;
29397   return jresult;
29398 }
29399
29400
29401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29402   void * jresult ;
29403   int arg1 ;
29404   Dali::TouchPoint::State arg2 ;
29405   float arg3 ;
29406   float arg4 ;
29407   Dali::TouchPoint *result = 0 ;
29408
29409   arg1 = (int)jarg1;
29410   arg2 = (Dali::TouchPoint::State)jarg2;
29411   arg3 = (float)jarg3;
29412   arg4 = (float)jarg4;
29413   {
29414     try {
29415       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29416     } catch (std::out_of_range& e) {
29417       {
29418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29419       };
29420     } catch (std::exception& e) {
29421       {
29422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29423       };
29424     } catch (Dali::DaliException e) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29431       };
29432     }
29433   }
29434
29435   jresult = (void *)result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29441   void * jresult ;
29442   int arg1 ;
29443   Dali::TouchPoint::State arg2 ;
29444   float arg3 ;
29445   float arg4 ;
29446   float arg5 ;
29447   float arg6 ;
29448   Dali::TouchPoint *result = 0 ;
29449
29450   arg1 = (int)jarg1;
29451   arg2 = (Dali::TouchPoint::State)jarg2;
29452   arg3 = (float)jarg3;
29453   arg4 = (float)jarg4;
29454   arg5 = (float)jarg5;
29455   arg6 = (float)jarg6;
29456   {
29457     try {
29458       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29459     } catch (std::out_of_range& e) {
29460       {
29461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29462       };
29463     } catch (std::exception& e) {
29464       {
29465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29466       };
29467     } catch (Dali::DaliException e) {
29468       {
29469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29470       };
29471     } catch (...) {
29472       {
29473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29474       };
29475     }
29476   }
29477
29478   jresult = (void *)result;
29479   return jresult;
29480 }
29481
29482
29483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29484   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29485
29486   arg1 = (Dali::TouchPoint *)jarg1;
29487   {
29488     try {
29489       delete arg1;
29490     } catch (std::out_of_range& e) {
29491       {
29492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29493       };
29494     } catch (std::exception& e) {
29495       {
29496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29497       };
29498     } catch (Dali::DaliException e) {
29499       {
29500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29501       };
29502     } catch (...) {
29503       {
29504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29505       };
29506     }
29507   }
29508
29509 }
29510
29511
29512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29513   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29514   int arg2 ;
29515
29516   arg1 = (Dali::TouchPoint *)jarg1;
29517   arg2 = (int)jarg2;
29518   if (arg1) (arg1)->deviceId = arg2;
29519 }
29520
29521
29522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29523   int jresult ;
29524   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29525   int result;
29526
29527   arg1 = (Dali::TouchPoint *)jarg1;
29528   result = (int) ((arg1)->deviceId);
29529   jresult = result;
29530   return jresult;
29531 }
29532
29533
29534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29535   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29536   Dali::TouchPoint::State arg2 ;
29537
29538   arg1 = (Dali::TouchPoint *)jarg1;
29539   arg2 = (Dali::TouchPoint::State)jarg2;
29540   if (arg1) (arg1)->state = arg2;
29541 }
29542
29543
29544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29545   int jresult ;
29546   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29547   Dali::TouchPoint::State result;
29548
29549   arg1 = (Dali::TouchPoint *)jarg1;
29550   result = (Dali::TouchPoint::State) ((arg1)->state);
29551   jresult = (int)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29557   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29558   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29559
29560   arg1 = (Dali::TouchPoint *)jarg1;
29561   arg2 = (Dali::Actor *)jarg2;
29562   if (arg1) (arg1)->hitActor = *arg2;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29567   void * jresult ;
29568   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29569   Dali::Actor *result = 0 ;
29570
29571   arg1 = (Dali::TouchPoint *)jarg1;
29572   result = (Dali::Actor *)& ((arg1)->hitActor);
29573   jresult = (void *)result;
29574   return jresult;
29575 }
29576
29577
29578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29579   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29580   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29581
29582   arg1 = (Dali::TouchPoint *)jarg1;
29583   arg2 = (Dali::Vector2 *)jarg2;
29584   if (arg1) (arg1)->local = *arg2;
29585 }
29586
29587
29588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29589   void * jresult ;
29590   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29591   Dali::Vector2 *result = 0 ;
29592
29593   arg1 = (Dali::TouchPoint *)jarg1;
29594   result = (Dali::Vector2 *)& ((arg1)->local);
29595   jresult = (void *)result;
29596   return jresult;
29597 }
29598
29599
29600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29601   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29602   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29603
29604   arg1 = (Dali::TouchPoint *)jarg1;
29605   arg2 = (Dali::Vector2 *)jarg2;
29606   if (arg1) (arg1)->screen = *arg2;
29607 }
29608
29609
29610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29611   void * jresult ;
29612   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29613   Dali::Vector2 *result = 0 ;
29614
29615   arg1 = (Dali::TouchPoint *)jarg1;
29616   result = (Dali::Vector2 *)& ((arg1)->screen);
29617   jresult = (void *)result;
29618   return jresult;
29619 }
29620
29621
29622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29623   void * jresult ;
29624   Dali::TouchData *result = 0 ;
29625
29626   {
29627     try {
29628       result = (Dali::TouchData *)new Dali::TouchData();
29629     } catch (std::out_of_range& e) {
29630       {
29631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29632       };
29633     } catch (std::exception& e) {
29634       {
29635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (Dali::DaliException e) {
29638       {
29639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29640       };
29641     } catch (...) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29644       };
29645     }
29646   }
29647
29648   jresult = (void *)result;
29649   return jresult;
29650 }
29651
29652
29653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29654   void * jresult ;
29655   Dali::TouchData *arg1 = 0 ;
29656   Dali::TouchData *result = 0 ;
29657
29658   arg1 = (Dali::TouchData *)jarg1;
29659   if (!arg1) {
29660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29661     return 0;
29662   }
29663   {
29664     try {
29665       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29666     } catch (std::out_of_range& e) {
29667       {
29668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29669       };
29670     } catch (std::exception& e) {
29671       {
29672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29673       };
29674     } catch (Dali::DaliException e) {
29675       {
29676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29677       };
29678     } catch (...) {
29679       {
29680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29681       };
29682     }
29683   }
29684
29685   jresult = (void *)result;
29686   return jresult;
29687 }
29688
29689
29690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29691   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29692
29693   arg1 = (Dali::TouchData *)jarg1;
29694   {
29695     try {
29696       delete arg1;
29697     } catch (std::out_of_range& e) {
29698       {
29699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29700       };
29701     } catch (std::exception& e) {
29702       {
29703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29704       };
29705     } catch (Dali::DaliException e) {
29706       {
29707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29708       };
29709     } catch (...) {
29710       {
29711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29712       };
29713     }
29714   }
29715
29716 }
29717
29718
29719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29720   void * jresult ;
29721   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29722   Dali::TouchData *arg2 = 0 ;
29723   Dali::TouchData *result = 0 ;
29724
29725   arg1 = (Dali::TouchData *)jarg1;
29726   arg2 = (Dali::TouchData *)jarg2;
29727   if (!arg2) {
29728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29729     return 0;
29730   }
29731   {
29732     try {
29733       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29734     } catch (std::out_of_range& e) {
29735       {
29736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29737       };
29738     } catch (std::exception& e) {
29739       {
29740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (Dali::DaliException e) {
29743       {
29744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29745       };
29746     } catch (...) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29749       };
29750     }
29751   }
29752
29753   jresult = (void *)result;
29754   return jresult;
29755 }
29756
29757
29758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29759   unsigned long jresult ;
29760   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29761   unsigned long result;
29762
29763   arg1 = (Dali::TouchData *)jarg1;
29764   {
29765     try {
29766       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29767     } catch (std::out_of_range& e) {
29768       {
29769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29770       };
29771     } catch (std::exception& e) {
29772       {
29773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29774       };
29775     } catch (Dali::DaliException e) {
29776       {
29777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29778       };
29779     } catch (...) {
29780       {
29781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29782       };
29783     }
29784   }
29785
29786   jresult = (unsigned long)result;
29787   return jresult;
29788 }
29789
29790
29791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29792   unsigned long jresult ;
29793   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29794   std::size_t result;
29795
29796   arg1 = (Dali::TouchData *)jarg1;
29797   {
29798     try {
29799       result = ((Dali::TouchData const *)arg1)->GetPointCount();
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 = (unsigned long)result;
29820   return jresult;
29821 }
29822
29823
29824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29825   int jresult ;
29826   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29827   std::size_t arg2 ;
29828   int32_t result;
29829
29830   arg1 = (Dali::TouchData *)jarg1;
29831   arg2 = (std::size_t)jarg2;
29832   {
29833     try {
29834       result = ((Dali::TouchData const *)arg1)->GetDeviceId(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 int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29860   int jresult ;
29861   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29862   std::size_t arg2 ;
29863   Dali::PointState::Type result;
29864
29865   arg1 = (Dali::TouchData *)jarg1;
29866   arg2 = (std::size_t)jarg2;
29867   {
29868     try {
29869       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(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 = (int)result;
29890   return jresult;
29891 }
29892
29893
29894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29895   void * jresult ;
29896   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29897   std::size_t arg2 ;
29898   Dali::Actor result;
29899
29900   arg1 = (Dali::TouchData *)jarg1;
29901   arg2 = (std::size_t)jarg2;
29902   {
29903     try {
29904       result = ((Dali::TouchData const *)arg1)->GetHitActor(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 = new Dali::Actor((const Dali::Actor &)result);
29925   return jresult;
29926 }
29927
29928
29929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29930   void * jresult ;
29931   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29932   std::size_t arg2 ;
29933   Dali::Vector2 *result = 0 ;
29934
29935   arg1 = (Dali::TouchData *)jarg1;
29936   arg2 = (std::size_t)jarg2;
29937   {
29938     try {
29939       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(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 = (void *)result;
29960   return jresult;
29961 }
29962
29963
29964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29965   void * jresult ;
29966   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29967   std::size_t arg2 ;
29968   Dali::Vector2 *result = 0 ;
29969
29970   arg1 = (Dali::TouchData *)jarg1;
29971   arg2 = (std::size_t)jarg2;
29972   {
29973     try {
29974       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(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 = (void *)result;
29995   return jresult;
29996 }
29997
29998
29999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30000   float jresult ;
30001   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30002   std::size_t arg2 ;
30003   float result;
30004
30005   arg1 = (Dali::TouchData *)jarg1;
30006   arg2 = (std::size_t)jarg2;
30007   {
30008     try {
30009       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30010     } catch (std::out_of_range& e) {
30011       {
30012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30013       };
30014     } catch (std::exception& e) {
30015       {
30016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30017       };
30018     } catch (Dali::DaliException e) {
30019       {
30020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30021       };
30022     } catch (...) {
30023       {
30024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30025       };
30026     }
30027   }
30028
30029   jresult = result;
30030   return jresult;
30031 }
30032
30033
30034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30035   void * jresult ;
30036   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30037   std::size_t arg2 ;
30038   Dali::Vector2 *result = 0 ;
30039
30040   arg1 = (Dali::TouchData *)jarg1;
30041   arg2 = (std::size_t)jarg2;
30042   {
30043     try {
30044       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
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 = (void *)result;
30065   return jresult;
30066 }
30067
30068
30069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30070   float jresult ;
30071   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30072   std::size_t arg2 ;
30073   float result;
30074
30075   arg1 = (Dali::TouchData *)jarg1;
30076   arg2 = (std::size_t)jarg2;
30077   {
30078     try {
30079       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30080     } catch (std::out_of_range& e) {
30081       {
30082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30083       };
30084     } catch (std::exception& e) {
30085       {
30086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30087       };
30088     } catch (Dali::DaliException e) {
30089       {
30090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30091       };
30092     } catch (...) {
30093       {
30094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30095       };
30096     }
30097   }
30098
30099   jresult = result;
30100   return jresult;
30101 }
30102
30103
30104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30105   void * jresult ;
30106   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30107   std::size_t arg2 ;
30108   Dali::Degree result;
30109
30110   arg1 = (Dali::TouchData *)jarg1;
30111   arg2 = (std::size_t)jarg2;
30112   {
30113     try {
30114       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30115     } catch (std::out_of_range& e) {
30116       {
30117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30118       };
30119     } catch (std::exception& e) {
30120       {
30121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30122       };
30123     } catch (Dali::DaliException e) {
30124       {
30125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30126       };
30127     } catch (...) {
30128       {
30129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30130       };
30131     }
30132   }
30133
30134   jresult = new Dali::Degree((const Dali::Degree &)result);
30135   return jresult;
30136 }
30137
30138
30139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30140   void * jresult ;
30141   Dali::GestureDetector *result = 0 ;
30142
30143   {
30144     try {
30145       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30146     } catch (std::out_of_range& e) {
30147       {
30148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30149       };
30150     } catch (std::exception& e) {
30151       {
30152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30153       };
30154     } catch (Dali::DaliException e) {
30155       {
30156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30157       };
30158     } catch (...) {
30159       {
30160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30161       };
30162     }
30163   }
30164
30165   jresult = (void *)result;
30166   return jresult;
30167 }
30168
30169
30170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30171   void * jresult ;
30172   Dali::BaseHandle arg1 ;
30173   Dali::BaseHandle *argp1 ;
30174   Dali::GestureDetector result;
30175
30176   argp1 = (Dali::BaseHandle *)jarg1;
30177   if (!argp1) {
30178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30179     return 0;
30180   }
30181   arg1 = *argp1;
30182   {
30183     try {
30184       result = Dali::GestureDetector::DownCast(arg1);
30185     } catch (std::out_of_range& e) {
30186       {
30187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30188       };
30189     } catch (std::exception& e) {
30190       {
30191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30192       };
30193     } catch (Dali::DaliException e) {
30194       {
30195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30196       };
30197     } catch (...) {
30198       {
30199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30200       };
30201     }
30202   }
30203
30204   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30205   return jresult;
30206 }
30207
30208
30209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30210   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30211
30212   arg1 = (Dali::GestureDetector *)jarg1;
30213   {
30214     try {
30215       delete arg1;
30216     } catch (std::out_of_range& e) {
30217       {
30218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30219       };
30220     } catch (std::exception& e) {
30221       {
30222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30223       };
30224     } catch (Dali::DaliException e) {
30225       {
30226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30227       };
30228     } catch (...) {
30229       {
30230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30231       };
30232     }
30233   }
30234
30235 }
30236
30237
30238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30239   void * jresult ;
30240   Dali::GestureDetector *arg1 = 0 ;
30241   Dali::GestureDetector *result = 0 ;
30242
30243   arg1 = (Dali::GestureDetector *)jarg1;
30244   if (!arg1) {
30245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30246     return 0;
30247   }
30248   {
30249     try {
30250       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30251     } catch (std::out_of_range& e) {
30252       {
30253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30254       };
30255     } catch (std::exception& e) {
30256       {
30257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30258       };
30259     } catch (Dali::DaliException e) {
30260       {
30261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30262       };
30263     } catch (...) {
30264       {
30265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30266       };
30267     }
30268   }
30269
30270   jresult = (void *)result;
30271   return jresult;
30272 }
30273
30274
30275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30276   void * jresult ;
30277   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30278   Dali::GestureDetector *arg2 = 0 ;
30279   Dali::GestureDetector *result = 0 ;
30280
30281   arg1 = (Dali::GestureDetector *)jarg1;
30282   arg2 = (Dali::GestureDetector *)jarg2;
30283   if (!arg2) {
30284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30285     return 0;
30286   }
30287   {
30288     try {
30289       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30290     } catch (std::out_of_range& e) {
30291       {
30292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30293       };
30294     } catch (std::exception& e) {
30295       {
30296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (Dali::DaliException e) {
30299       {
30300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30301       };
30302     } catch (...) {
30303       {
30304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30305       };
30306     }
30307   }
30308
30309   jresult = (void *)result;
30310   return jresult;
30311 }
30312
30313
30314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30315   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30316   Dali::Actor arg2 ;
30317   Dali::Actor *argp2 ;
30318
30319   arg1 = (Dali::GestureDetector *)jarg1;
30320   argp2 = (Dali::Actor *)jarg2;
30321   if (!argp2) {
30322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30323     return ;
30324   }
30325   arg2 = *argp2;
30326   {
30327     try {
30328       (arg1)->Attach(arg2);
30329     } catch (std::out_of_range& e) {
30330       {
30331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30332       };
30333     } catch (std::exception& e) {
30334       {
30335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30336       };
30337     } catch (Dali::DaliException e) {
30338       {
30339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30340       };
30341     } catch (...) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30344       };
30345     }
30346   }
30347
30348 }
30349
30350
30351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30352   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30353   Dali::Actor arg2 ;
30354   Dali::Actor *argp2 ;
30355
30356   arg1 = (Dali::GestureDetector *)jarg1;
30357   argp2 = (Dali::Actor *)jarg2;
30358   if (!argp2) {
30359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30360     return ;
30361   }
30362   arg2 = *argp2;
30363   {
30364     try {
30365       (arg1)->Detach(arg2);
30366     } catch (std::out_of_range& e) {
30367       {
30368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30369       };
30370     } catch (std::exception& e) {
30371       {
30372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30373       };
30374     } catch (Dali::DaliException e) {
30375       {
30376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30377       };
30378     } catch (...) {
30379       {
30380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30381       };
30382     }
30383   }
30384
30385 }
30386
30387
30388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30389   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30390
30391   arg1 = (Dali::GestureDetector *)jarg1;
30392   {
30393     try {
30394       (arg1)->DetachAll();
30395     } catch (std::out_of_range& e) {
30396       {
30397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30398       };
30399     } catch (std::exception& e) {
30400       {
30401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30402       };
30403     } catch (Dali::DaliException e) {
30404       {
30405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30406       };
30407     } catch (...) {
30408       {
30409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30410       };
30411     }
30412   }
30413
30414 }
30415
30416
30417 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30418   unsigned long jresult ;
30419   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30420   size_t result;
30421
30422   arg1 = (Dali::GestureDetector *)jarg1;
30423   {
30424     try {
30425       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30426     } catch (std::out_of_range& e) {
30427       {
30428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30429       };
30430     } catch (std::exception& e) {
30431       {
30432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30433       };
30434     } catch (Dali::DaliException e) {
30435       {
30436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30437       };
30438     } catch (...) {
30439       {
30440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30441       };
30442     }
30443   }
30444
30445   jresult = (unsigned long)result;
30446   return jresult;
30447 }
30448
30449
30450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30451   void * jresult ;
30452   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30453   size_t arg2 ;
30454   Dali::Actor result;
30455
30456   arg1 = (Dali::GestureDetector *)jarg1;
30457   arg2 = (size_t)jarg2;
30458   {
30459     try {
30460       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30468       };
30469     } catch (Dali::DaliException e) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30472       };
30473     } catch (...) {
30474       {
30475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30476       };
30477     }
30478   }
30479
30480   jresult = new Dali::Actor((const Dali::Actor &)result);
30481   return jresult;
30482 }
30483
30484
30485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30486   void * jresult ;
30487   Dali::Gesture *arg1 = 0 ;
30488   Dali::Gesture *result = 0 ;
30489
30490   arg1 = (Dali::Gesture *)jarg1;
30491   if (!arg1) {
30492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30493     return 0;
30494   }
30495   {
30496     try {
30497       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30513       };
30514     }
30515   }
30516
30517   jresult = (void *)result;
30518   return jresult;
30519 }
30520
30521
30522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30523   void * jresult ;
30524   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30525   Dali::Gesture *arg2 = 0 ;
30526   Dali::Gesture *result = 0 ;
30527
30528   arg1 = (Dali::Gesture *)jarg1;
30529   arg2 = (Dali::Gesture *)jarg2;
30530   if (!arg2) {
30531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30532     return 0;
30533   }
30534   {
30535     try {
30536       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30537     } catch (std::out_of_range& e) {
30538       {
30539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (std::exception& e) {
30542       {
30543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30544       };
30545     } catch (Dali::DaliException e) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30548       };
30549     } catch (...) {
30550       {
30551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30552       };
30553     }
30554   }
30555
30556   jresult = (void *)result;
30557   return jresult;
30558 }
30559
30560
30561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30562   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30563
30564   arg1 = (Dali::Gesture *)jarg1;
30565   {
30566     try {
30567       delete arg1;
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30583       };
30584     }
30585   }
30586
30587 }
30588
30589
30590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30591   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30592   Dali::Gesture::Type arg2 ;
30593
30594   arg1 = (Dali::Gesture *)jarg1;
30595   arg2 = (Dali::Gesture::Type)jarg2;
30596   if (arg1) (arg1)->type = arg2;
30597 }
30598
30599
30600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30601   int jresult ;
30602   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30603   Dali::Gesture::Type result;
30604
30605   arg1 = (Dali::Gesture *)jarg1;
30606   result = (Dali::Gesture::Type) ((arg1)->type);
30607   jresult = (int)result;
30608   return jresult;
30609 }
30610
30611
30612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30613   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30614   Dali::Gesture::State arg2 ;
30615
30616   arg1 = (Dali::Gesture *)jarg1;
30617   arg2 = (Dali::Gesture::State)jarg2;
30618   if (arg1) (arg1)->state = arg2;
30619 }
30620
30621
30622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30623   int jresult ;
30624   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30625   Dali::Gesture::State result;
30626
30627   arg1 = (Dali::Gesture *)jarg1;
30628   result = (Dali::Gesture::State) ((arg1)->state);
30629   jresult = (int)result;
30630   return jresult;
30631 }
30632
30633
30634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30635   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30636   unsigned int arg2 ;
30637
30638   arg1 = (Dali::Gesture *)jarg1;
30639   arg2 = (unsigned int)jarg2;
30640   if (arg1) (arg1)->time = arg2;
30641 }
30642
30643
30644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30645   unsigned int jresult ;
30646   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30647   unsigned int result;
30648
30649   arg1 = (Dali::Gesture *)jarg1;
30650   result = (unsigned int) ((arg1)->time);
30651   jresult = result;
30652   return jresult;
30653 }
30654
30655
30656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30657   void * jresult ;
30658   Dali::HoverEvent *result = 0 ;
30659
30660   {
30661     try {
30662       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30663     } catch (std::out_of_range& e) {
30664       {
30665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (std::exception& e) {
30668       {
30669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30670       };
30671     } catch (Dali::DaliException e) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30674       };
30675     } catch (...) {
30676       {
30677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30678       };
30679     }
30680   }
30681
30682   jresult = (void *)result;
30683   return jresult;
30684 }
30685
30686
30687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30688   void * jresult ;
30689   unsigned long arg1 ;
30690   Dali::HoverEvent *result = 0 ;
30691
30692   arg1 = (unsigned long)jarg1;
30693   {
30694     try {
30695       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30696     } catch (std::out_of_range& e) {
30697       {
30698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30699       };
30700     } catch (std::exception& e) {
30701       {
30702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30703       };
30704     } catch (Dali::DaliException e) {
30705       {
30706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30707       };
30708     } catch (...) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30711       };
30712     }
30713   }
30714
30715   jresult = (void *)result;
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30721   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30722
30723   arg1 = (Dali::HoverEvent *)jarg1;
30724   {
30725     try {
30726       delete arg1;
30727     } catch (std::out_of_range& e) {
30728       {
30729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30730       };
30731     } catch (std::exception& e) {
30732       {
30733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (Dali::DaliException e) {
30736       {
30737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745
30746 }
30747
30748
30749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30750   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30751   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30752
30753   arg1 = (Dali::HoverEvent *)jarg1;
30754   arg2 = (Dali::TouchPointContainer *)jarg2;
30755   if (arg1) (arg1)->points = *arg2;
30756 }
30757
30758
30759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30760   void * jresult ;
30761   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30762   Dali::TouchPointContainer *result = 0 ;
30763
30764   arg1 = (Dali::HoverEvent *)jarg1;
30765   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30766   jresult = (void *)result;
30767   return jresult;
30768 }
30769
30770
30771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30772   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30773   unsigned long arg2 ;
30774
30775   arg1 = (Dali::HoverEvent *)jarg1;
30776   arg2 = (unsigned long)jarg2;
30777   if (arg1) (arg1)->time = arg2;
30778 }
30779
30780
30781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30782   unsigned long jresult ;
30783   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30784   unsigned long result;
30785
30786   arg1 = (Dali::HoverEvent *)jarg1;
30787   result = (unsigned long) ((arg1)->time);
30788   jresult = (unsigned long)result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30794   unsigned int jresult ;
30795   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30796   unsigned int result;
30797
30798   arg1 = (Dali::HoverEvent *)jarg1;
30799   {
30800     try {
30801       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30802     } catch (std::out_of_range& e) {
30803       {
30804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30805       };
30806     } catch (std::exception& e) {
30807       {
30808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30809       };
30810     } catch (Dali::DaliException e) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30813       };
30814     } catch (...) {
30815       {
30816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30817       };
30818     }
30819   }
30820
30821   jresult = result;
30822   return jresult;
30823 }
30824
30825
30826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30827   void * jresult ;
30828   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30829   unsigned int arg2 ;
30830   Dali::TouchPoint *result = 0 ;
30831
30832   arg1 = (Dali::HoverEvent *)jarg1;
30833   arg2 = (unsigned int)jarg2;
30834   {
30835     try {
30836       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30837     } catch (std::out_of_range& e) {
30838       {
30839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30840       };
30841     } catch (std::exception& e) {
30842       {
30843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30844       };
30845     } catch (Dali::DaliException e) {
30846       {
30847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30848       };
30849     } catch (...) {
30850       {
30851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30852       };
30853     }
30854   }
30855
30856   jresult = (void *)result;
30857   return jresult;
30858 }
30859
30860
30861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30862   void * jresult ;
30863   Dali::KeyEvent *result = 0 ;
30864
30865   {
30866     try {
30867       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30868     } catch (std::out_of_range& e) {
30869       {
30870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30871       };
30872     } catch (std::exception& e) {
30873       {
30874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30875       };
30876     } catch (Dali::DaliException e) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30879       };
30880     } catch (...) {
30881       {
30882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30883       };
30884     }
30885   }
30886
30887   jresult = (void *)result;
30888   return jresult;
30889 }
30890
30891
30892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30893   void * jresult ;
30894   std::string *arg1 = 0 ;
30895   std::string *arg2 = 0 ;
30896   int arg3 ;
30897   int arg4 ;
30898   unsigned long arg5 ;
30899   Dali::KeyEvent::State *arg6 = 0 ;
30900   Dali::KeyEvent::State temp6 ;
30901   Dali::KeyEvent *result = 0 ;
30902
30903   if (!jarg1) {
30904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30905     return 0;
30906   }
30907   std::string arg1_str(jarg1);
30908   arg1 = &arg1_str;
30909   if (!jarg2) {
30910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30911     return 0;
30912   }
30913   std::string arg2_str(jarg2);
30914   arg2 = &arg2_str;
30915   arg3 = (int)jarg3;
30916   arg4 = (int)jarg4;
30917   arg5 = (unsigned long)jarg5;
30918   temp6 = (Dali::KeyEvent::State)jarg6;
30919   arg6 = &temp6;
30920   {
30921     try {
30922       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30923     } catch (std::out_of_range& e) {
30924       {
30925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30926       };
30927     } catch (std::exception& e) {
30928       {
30929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30930       };
30931     } catch (Dali::DaliException e) {
30932       {
30933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30934       };
30935     } catch (...) {
30936       {
30937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30938       };
30939     }
30940   }
30941
30942   jresult = (void *)result;
30943
30944   //argout typemap for const std::string&
30945
30946
30947   //argout typemap for const std::string&
30948
30949   return jresult;
30950 }
30951
30952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30953   void * jresult ;
30954   Dali::KeyEvent *arg1 = 0 ;
30955   Dali::KeyEvent *result = 0 ;
30956
30957   arg1 = (Dali::KeyEvent *)jarg1;
30958   if (!arg1) {
30959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30960     return 0;
30961   }
30962   {
30963     try {
30964       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30965     } catch (std::out_of_range& e) {
30966       {
30967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30968       };
30969     } catch (std::exception& e) {
30970       {
30971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30972       };
30973     } catch (Dali::DaliException e) {
30974       {
30975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30976       };
30977     } catch (...) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30980       };
30981     }
30982   }
30983
30984   jresult = (void *)result;
30985   return jresult;
30986 }
30987
30988
30989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30990   void * jresult ;
30991   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30992   Dali::KeyEvent *arg2 = 0 ;
30993   Dali::KeyEvent *result = 0 ;
30994
30995   arg1 = (Dali::KeyEvent *)jarg1;
30996   arg2 = (Dali::KeyEvent *)jarg2;
30997   if (!arg2) {
30998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30999     return 0;
31000   }
31001   {
31002     try {
31003       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31004     } catch (std::out_of_range& e) {
31005       {
31006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31007       };
31008     } catch (std::exception& e) {
31009       {
31010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31011       };
31012     } catch (Dali::DaliException e) {
31013       {
31014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31015       };
31016     } catch (...) {
31017       {
31018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31019       };
31020     }
31021   }
31022
31023   jresult = (void *)result;
31024   return jresult;
31025 }
31026
31027
31028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31029   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31030
31031   arg1 = (Dali::KeyEvent *)jarg1;
31032   {
31033     try {
31034       delete arg1;
31035     } catch (std::out_of_range& e) {
31036       {
31037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31038       };
31039     } catch (std::exception& e) {
31040       {
31041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31042       };
31043     } catch (Dali::DaliException e) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31046       };
31047     } catch (...) {
31048       {
31049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31050       };
31051     }
31052   }
31053
31054 }
31055
31056
31057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31058   unsigned int jresult ;
31059   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31060   bool result;
31061
31062   arg1 = (Dali::KeyEvent *)jarg1;
31063   {
31064     try {
31065       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31066     } catch (std::out_of_range& e) {
31067       {
31068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31069       };
31070     } catch (std::exception& e) {
31071       {
31072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (Dali::DaliException e) {
31075       {
31076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31077       };
31078     } catch (...) {
31079       {
31080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31081       };
31082     }
31083   }
31084
31085   jresult = result;
31086   return jresult;
31087 }
31088
31089
31090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31091   unsigned int jresult ;
31092   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31093   bool result;
31094
31095   arg1 = (Dali::KeyEvent *)jarg1;
31096   {
31097     try {
31098       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31099     } catch (std::out_of_range& e) {
31100       {
31101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31102       };
31103     } catch (std::exception& e) {
31104       {
31105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31106       };
31107     } catch (Dali::DaliException e) {
31108       {
31109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31110       };
31111     } catch (...) {
31112       {
31113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31114       };
31115     }
31116   }
31117
31118   jresult = result;
31119   return jresult;
31120 }
31121
31122
31123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31124   unsigned int jresult ;
31125   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31126   bool result;
31127
31128   arg1 = (Dali::KeyEvent *)jarg1;
31129   {
31130     try {
31131       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31132     } catch (std::out_of_range& e) {
31133       {
31134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31135       };
31136     } catch (std::exception& e) {
31137       {
31138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31139       };
31140     } catch (Dali::DaliException e) {
31141       {
31142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31143       };
31144     } catch (...) {
31145       {
31146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31147       };
31148     }
31149   }
31150
31151   jresult = result;
31152   return jresult;
31153 }
31154
31155
31156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31157   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31158   std::string *arg2 = 0 ;
31159
31160   arg1 = (Dali::KeyEvent *)jarg1;
31161   if (!jarg2) {
31162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31163     return ;
31164   }
31165   std::string arg2_str(jarg2);
31166   arg2 = &arg2_str;
31167   if (arg1) (arg1)->keyPressedName = *arg2;
31168
31169   //argout typemap for const std::string&
31170
31171 }
31172
31173
31174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31175   char * jresult ;
31176   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31177   std::string *result = 0 ;
31178
31179   arg1 = (Dali::KeyEvent *)jarg1;
31180   result = (std::string *) & ((arg1)->keyPressedName);
31181   jresult = SWIG_csharp_string_callback(result->c_str());
31182   return jresult;
31183 }
31184
31185
31186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31187   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31188   std::string *arg2 = 0 ;
31189
31190   arg1 = (Dali::KeyEvent *)jarg1;
31191   if (!jarg2) {
31192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31193     return ;
31194   }
31195   std::string arg2_str(jarg2);
31196   arg2 = &arg2_str;
31197   if (arg1) (arg1)->keyPressed = *arg2;
31198
31199   //argout typemap for const std::string&
31200
31201 }
31202
31203
31204 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31205   char * jresult ;
31206   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31207   std::string *result = 0 ;
31208
31209   arg1 = (Dali::KeyEvent *)jarg1;
31210   result = (std::string *) & ((arg1)->keyPressed);
31211   jresult = SWIG_csharp_string_callback(result->c_str());
31212   return jresult;
31213 }
31214
31215
31216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31217   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31218   int arg2 ;
31219
31220   arg1 = (Dali::KeyEvent *)jarg1;
31221   arg2 = (int)jarg2;
31222   if (arg1) (arg1)->keyCode = arg2;
31223 }
31224
31225
31226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31227   int jresult ;
31228   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31229   int result;
31230
31231   arg1 = (Dali::KeyEvent *)jarg1;
31232   result = (int) ((arg1)->keyCode);
31233   jresult = result;
31234   return jresult;
31235 }
31236
31237
31238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31239   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31240   int arg2 ;
31241
31242   arg1 = (Dali::KeyEvent *)jarg1;
31243   arg2 = (int)jarg2;
31244   if (arg1) (arg1)->keyModifier = arg2;
31245 }
31246
31247
31248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31249   int jresult ;
31250   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31251   int result;
31252
31253   arg1 = (Dali::KeyEvent *)jarg1;
31254   result = (int) ((arg1)->keyModifier);
31255   jresult = result;
31256   return jresult;
31257 }
31258
31259
31260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31261   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31262   unsigned long arg2 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   arg2 = (unsigned long)jarg2;
31266   if (arg1) (arg1)->time = arg2;
31267 }
31268
31269
31270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31271   unsigned long jresult ;
31272   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31273   unsigned long result;
31274
31275   arg1 = (Dali::KeyEvent *)jarg1;
31276   result = (unsigned long) ((arg1)->time);
31277   jresult = (unsigned long)result;
31278   return jresult;
31279 }
31280
31281
31282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31283   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31284   Dali::KeyEvent::State arg2 ;
31285
31286   arg1 = (Dali::KeyEvent *)jarg1;
31287   arg2 = (Dali::KeyEvent::State)jarg2;
31288   if (arg1) (arg1)->state = arg2;
31289 }
31290
31291
31292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31293   int jresult ;
31294   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31295   Dali::KeyEvent::State result;
31296
31297   arg1 = (Dali::KeyEvent *)jarg1;
31298   result = (Dali::KeyEvent::State) ((arg1)->state);
31299   jresult = (int)result;
31300   return jresult;
31301 }
31302
31303
31304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31305   void * jresult ;
31306   Dali::LongPressGestureDetector *result = 0 ;
31307
31308   {
31309     try {
31310       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31311     } catch (std::out_of_range& e) {
31312       {
31313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31314       };
31315     } catch (std::exception& e) {
31316       {
31317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31318       };
31319     } catch (Dali::DaliException e) {
31320       {
31321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31322       };
31323     } catch (...) {
31324       {
31325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31326       };
31327     }
31328   }
31329
31330   jresult = (void *)result;
31331   return jresult;
31332 }
31333
31334
31335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31336   void * jresult ;
31337   Dali::LongPressGestureDetector result;
31338
31339   {
31340     try {
31341       result = Dali::LongPressGestureDetector::New();
31342     } catch (std::out_of_range& e) {
31343       {
31344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31345       };
31346     } catch (std::exception& e) {
31347       {
31348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31349       };
31350     } catch (Dali::DaliException e) {
31351       {
31352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31353       };
31354     } catch (...) {
31355       {
31356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31357       };
31358     }
31359   }
31360
31361   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31362   return jresult;
31363 }
31364
31365
31366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31367   void * jresult ;
31368   unsigned int arg1 ;
31369   Dali::LongPressGestureDetector result;
31370
31371   arg1 = (unsigned int)jarg1;
31372   {
31373     try {
31374       result = Dali::LongPressGestureDetector::New(arg1);
31375     } catch (std::out_of_range& e) {
31376       {
31377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31378       };
31379     } catch (std::exception& e) {
31380       {
31381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31382       };
31383     } catch (Dali::DaliException e) {
31384       {
31385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31386       };
31387     } catch (...) {
31388       {
31389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31390       };
31391     }
31392   }
31393
31394   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31395   return jresult;
31396 }
31397
31398
31399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31400   void * jresult ;
31401   unsigned int arg1 ;
31402   unsigned int arg2 ;
31403   Dali::LongPressGestureDetector result;
31404
31405   arg1 = (unsigned int)jarg1;
31406   arg2 = (unsigned int)jarg2;
31407   {
31408     try {
31409       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31410     } catch (std::out_of_range& e) {
31411       {
31412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31413       };
31414     } catch (std::exception& e) {
31415       {
31416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31417       };
31418     } catch (Dali::DaliException e) {
31419       {
31420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31421       };
31422     } catch (...) {
31423       {
31424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31425       };
31426     }
31427   }
31428
31429   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31430   return jresult;
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31435   void * jresult ;
31436   Dali::BaseHandle arg1 ;
31437   Dali::BaseHandle *argp1 ;
31438   Dali::LongPressGestureDetector result;
31439
31440   argp1 = (Dali::BaseHandle *)jarg1;
31441   if (!argp1) {
31442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31443     return 0;
31444   }
31445   arg1 = *argp1;
31446   {
31447     try {
31448       result = Dali::LongPressGestureDetector::DownCast(arg1);
31449     } catch (std::out_of_range& e) {
31450       {
31451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31452       };
31453     } catch (std::exception& e) {
31454       {
31455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31456       };
31457     } catch (Dali::DaliException e) {
31458       {
31459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31460       };
31461     } catch (...) {
31462       {
31463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31464       };
31465     }
31466   }
31467
31468   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31469   return jresult;
31470 }
31471
31472
31473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31474   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31475
31476   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31477   {
31478     try {
31479       delete arg1;
31480     } catch (std::out_of_range& e) {
31481       {
31482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31483       };
31484     } catch (std::exception& e) {
31485       {
31486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31487       };
31488     } catch (Dali::DaliException e) {
31489       {
31490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31491       };
31492     } catch (...) {
31493       {
31494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31495       };
31496     }
31497   }
31498
31499 }
31500
31501
31502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31503   void * jresult ;
31504   Dali::LongPressGestureDetector *arg1 = 0 ;
31505   Dali::LongPressGestureDetector *result = 0 ;
31506
31507   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31508   if (!arg1) {
31509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31510     return 0;
31511   }
31512   {
31513     try {
31514       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31515     } catch (std::out_of_range& e) {
31516       {
31517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31518       };
31519     } catch (std::exception& e) {
31520       {
31521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31522       };
31523     } catch (Dali::DaliException e) {
31524       {
31525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31526       };
31527     } catch (...) {
31528       {
31529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31530       };
31531     }
31532   }
31533
31534   jresult = (void *)result;
31535   return jresult;
31536 }
31537
31538
31539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31540   void * jresult ;
31541   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31542   Dali::LongPressGestureDetector *arg2 = 0 ;
31543   Dali::LongPressGestureDetector *result = 0 ;
31544
31545   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31546   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31547   if (!arg2) {
31548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31549     return 0;
31550   }
31551   {
31552     try {
31553       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31554     } catch (std::out_of_range& e) {
31555       {
31556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31557       };
31558     } catch (std::exception& e) {
31559       {
31560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (Dali::DaliException e) {
31563       {
31564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31565       };
31566     } catch (...) {
31567       {
31568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31569       };
31570     }
31571   }
31572
31573   jresult = (void *)result;
31574   return jresult;
31575 }
31576
31577
31578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31579   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31580   unsigned int arg2 ;
31581
31582   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31583   arg2 = (unsigned int)jarg2;
31584   {
31585     try {
31586       (arg1)->SetTouchesRequired(arg2);
31587     } catch (std::out_of_range& e) {
31588       {
31589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31590       };
31591     } catch (std::exception& e) {
31592       {
31593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31594       };
31595     } catch (Dali::DaliException e) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31598       };
31599     } catch (...) {
31600       {
31601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31602       };
31603     }
31604   }
31605
31606 }
31607
31608
31609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31610   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31611   unsigned int arg2 ;
31612   unsigned int arg3 ;
31613
31614   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31615   arg2 = (unsigned int)jarg2;
31616   arg3 = (unsigned int)jarg3;
31617   {
31618     try {
31619       (arg1)->SetTouchesRequired(arg2,arg3);
31620     } catch (std::out_of_range& e) {
31621       {
31622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31623       };
31624     } catch (std::exception& e) {
31625       {
31626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31627       };
31628     } catch (Dali::DaliException e) {
31629       {
31630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31631       };
31632     } catch (...) {
31633       {
31634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31635       };
31636     }
31637   }
31638
31639 }
31640
31641
31642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31643   unsigned int jresult ;
31644   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31645   unsigned int result;
31646
31647   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31648   {
31649     try {
31650       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31651     } catch (std::out_of_range& e) {
31652       {
31653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31654       };
31655     } catch (std::exception& e) {
31656       {
31657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31658       };
31659     } catch (Dali::DaliException e) {
31660       {
31661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31662       };
31663     } catch (...) {
31664       {
31665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31666       };
31667     }
31668   }
31669
31670   jresult = result;
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31676   unsigned int jresult ;
31677   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31678   unsigned int result;
31679
31680   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31681   {
31682     try {
31683       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31684     } catch (std::out_of_range& e) {
31685       {
31686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31687       };
31688     } catch (std::exception& e) {
31689       {
31690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31691       };
31692     } catch (Dali::DaliException e) {
31693       {
31694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31695       };
31696     } catch (...) {
31697       {
31698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31699       };
31700     }
31701   }
31702
31703   jresult = result;
31704   return jresult;
31705 }
31706
31707
31708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31709   void * jresult ;
31710   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31711   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31712
31713   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31714   {
31715     try {
31716       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31717     } catch (std::out_of_range& e) {
31718       {
31719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31720       };
31721     } catch (std::exception& e) {
31722       {
31723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31724       };
31725     } catch (Dali::DaliException e) {
31726       {
31727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31728       };
31729     } catch (...) {
31730       {
31731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31732       };
31733     }
31734   }
31735
31736   jresult = (void *)result;
31737   return jresult;
31738 }
31739
31740
31741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31742   void * jresult ;
31743   Dali::Gesture::State arg1 ;
31744   Dali::LongPressGesture *result = 0 ;
31745
31746   arg1 = (Dali::Gesture::State)jarg1;
31747   {
31748     try {
31749       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31750     } catch (std::out_of_range& e) {
31751       {
31752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31753       };
31754     } catch (std::exception& e) {
31755       {
31756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31757       };
31758     } catch (Dali::DaliException e) {
31759       {
31760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31761       };
31762     } catch (...) {
31763       {
31764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31765       };
31766     }
31767   }
31768
31769   jresult = (void *)result;
31770   return jresult;
31771 }
31772
31773
31774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31775   void * jresult ;
31776   Dali::LongPressGesture *arg1 = 0 ;
31777   Dali::LongPressGesture *result = 0 ;
31778
31779   arg1 = (Dali::LongPressGesture *)jarg1;
31780   if (!arg1) {
31781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31782     return 0;
31783   }
31784   {
31785     try {
31786       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31787     } catch (std::out_of_range& e) {
31788       {
31789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31790       };
31791     } catch (std::exception& e) {
31792       {
31793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31794       };
31795     } catch (Dali::DaliException e) {
31796       {
31797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31798       };
31799     } catch (...) {
31800       {
31801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31802       };
31803     }
31804   }
31805
31806   jresult = (void *)result;
31807   return jresult;
31808 }
31809
31810
31811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31812   void * jresult ;
31813   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31814   Dali::LongPressGesture *arg2 = 0 ;
31815   Dali::LongPressGesture *result = 0 ;
31816
31817   arg1 = (Dali::LongPressGesture *)jarg1;
31818   arg2 = (Dali::LongPressGesture *)jarg2;
31819   if (!arg2) {
31820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31821     return 0;
31822   }
31823   {
31824     try {
31825       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31826     } catch (std::out_of_range& e) {
31827       {
31828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31829       };
31830     } catch (std::exception& e) {
31831       {
31832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31833       };
31834     } catch (Dali::DaliException e) {
31835       {
31836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31837       };
31838     } catch (...) {
31839       {
31840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31841       };
31842     }
31843   }
31844
31845   jresult = (void *)result;
31846   return jresult;
31847 }
31848
31849
31850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31851   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31852
31853   arg1 = (Dali::LongPressGesture *)jarg1;
31854   {
31855     try {
31856       delete arg1;
31857     } catch (std::out_of_range& e) {
31858       {
31859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31860       };
31861     } catch (std::exception& e) {
31862       {
31863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31864       };
31865     } catch (Dali::DaliException e) {
31866       {
31867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31868       };
31869     } catch (...) {
31870       {
31871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31872       };
31873     }
31874   }
31875
31876 }
31877
31878
31879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31880   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31881   unsigned int arg2 ;
31882
31883   arg1 = (Dali::LongPressGesture *)jarg1;
31884   arg2 = (unsigned int)jarg2;
31885   if (arg1) (arg1)->numberOfTouches = arg2;
31886 }
31887
31888
31889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31890   unsigned int jresult ;
31891   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31892   unsigned int result;
31893
31894   arg1 = (Dali::LongPressGesture *)jarg1;
31895   result = (unsigned int) ((arg1)->numberOfTouches);
31896   jresult = result;
31897   return jresult;
31898 }
31899
31900
31901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31902   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31903   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31904
31905   arg1 = (Dali::LongPressGesture *)jarg1;
31906   arg2 = (Dali::Vector2 *)jarg2;
31907   if (arg1) (arg1)->screenPoint = *arg2;
31908 }
31909
31910
31911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31912   void * jresult ;
31913   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31914   Dali::Vector2 *result = 0 ;
31915
31916   arg1 = (Dali::LongPressGesture *)jarg1;
31917   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31918   jresult = (void *)result;
31919   return jresult;
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31924   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31925   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31926
31927   arg1 = (Dali::LongPressGesture *)jarg1;
31928   arg2 = (Dali::Vector2 *)jarg2;
31929   if (arg1) (arg1)->localPoint = *arg2;
31930 }
31931
31932
31933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31934   void * jresult ;
31935   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31936   Dali::Vector2 *result = 0 ;
31937
31938   arg1 = (Dali::LongPressGesture *)jarg1;
31939   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31940   jresult = (void *)result;
31941   return jresult;
31942 }
31943
31944
31945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31946   void * jresult ;
31947   Dali::WheelEvent *result = 0 ;
31948
31949   {
31950     try {
31951       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31952     } catch (std::out_of_range& e) {
31953       {
31954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31955       };
31956     } catch (std::exception& e) {
31957       {
31958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31959       };
31960     } catch (Dali::DaliException e) {
31961       {
31962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31963       };
31964     } catch (...) {
31965       {
31966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31967       };
31968     }
31969   }
31970
31971   jresult = (void *)result;
31972   return jresult;
31973 }
31974
31975
31976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31977   void * jresult ;
31978   Dali::WheelEvent::Type arg1 ;
31979   int arg2 ;
31980   unsigned int arg3 ;
31981   Dali::Vector2 arg4 ;
31982   int arg5 ;
31983   unsigned int arg6 ;
31984   Dali::Vector2 *argp4 ;
31985   Dali::WheelEvent *result = 0 ;
31986
31987   arg1 = (Dali::WheelEvent::Type)jarg1;
31988   arg2 = (int)jarg2;
31989   arg3 = (unsigned int)jarg3;
31990   argp4 = (Dali::Vector2 *)jarg4;
31991   if (!argp4) {
31992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31993     return 0;
31994   }
31995   arg4 = *argp4;
31996   arg5 = (int)jarg5;
31997   arg6 = (unsigned int)jarg6;
31998   {
31999     try {
32000       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32001     } catch (std::out_of_range& e) {
32002       {
32003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32004       };
32005     } catch (std::exception& e) {
32006       {
32007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32008       };
32009     } catch (Dali::DaliException e) {
32010       {
32011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32012       };
32013     } catch (...) {
32014       {
32015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32016       };
32017     }
32018   }
32019
32020   jresult = (void *)result;
32021   return jresult;
32022 }
32023
32024
32025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32026   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32027
32028   arg1 = (Dali::WheelEvent *)jarg1;
32029   {
32030     try {
32031       delete arg1;
32032     } catch (std::out_of_range& e) {
32033       {
32034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32035       };
32036     } catch (std::exception& e) {
32037       {
32038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32039       };
32040     } catch (Dali::DaliException e) {
32041       {
32042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32043       };
32044     } catch (...) {
32045       {
32046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32047       };
32048     }
32049   }
32050
32051 }
32052
32053
32054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32055   unsigned int jresult ;
32056   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32057   bool result;
32058
32059   arg1 = (Dali::WheelEvent *)jarg1;
32060   {
32061     try {
32062       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32063     } catch (std::out_of_range& e) {
32064       {
32065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32066       };
32067     } catch (std::exception& e) {
32068       {
32069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32070       };
32071     } catch (Dali::DaliException e) {
32072       {
32073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32074       };
32075     } catch (...) {
32076       {
32077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32078       };
32079     }
32080   }
32081
32082   jresult = result;
32083   return jresult;
32084 }
32085
32086
32087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32088   unsigned int jresult ;
32089   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32090   bool result;
32091
32092   arg1 = (Dali::WheelEvent *)jarg1;
32093   {
32094     try {
32095       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32096     } catch (std::out_of_range& e) {
32097       {
32098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32099       };
32100     } catch (std::exception& e) {
32101       {
32102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (Dali::DaliException e) {
32105       {
32106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32107       };
32108     } catch (...) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32111       };
32112     }
32113   }
32114
32115   jresult = result;
32116   return jresult;
32117 }
32118
32119
32120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32121   unsigned int jresult ;
32122   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32123   bool result;
32124
32125   arg1 = (Dali::WheelEvent *)jarg1;
32126   {
32127     try {
32128       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32129     } catch (std::out_of_range& e) {
32130       {
32131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32132       };
32133     } catch (std::exception& e) {
32134       {
32135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32136       };
32137     } catch (Dali::DaliException e) {
32138       {
32139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32140       };
32141     } catch (...) {
32142       {
32143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32144       };
32145     }
32146   }
32147
32148   jresult = result;
32149   return jresult;
32150 }
32151
32152
32153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32154   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32155   Dali::WheelEvent::Type arg2 ;
32156
32157   arg1 = (Dali::WheelEvent *)jarg1;
32158   arg2 = (Dali::WheelEvent::Type)jarg2;
32159   if (arg1) (arg1)->type = arg2;
32160 }
32161
32162
32163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32164   int jresult ;
32165   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32166   Dali::WheelEvent::Type result;
32167
32168   arg1 = (Dali::WheelEvent *)jarg1;
32169   result = (Dali::WheelEvent::Type) ((arg1)->type);
32170   jresult = (int)result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32177   int arg2 ;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   arg2 = (int)jarg2;
32181   if (arg1) (arg1)->direction = arg2;
32182 }
32183
32184
32185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32186   int jresult ;
32187   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32188   int result;
32189
32190   arg1 = (Dali::WheelEvent *)jarg1;
32191   result = (int) ((arg1)->direction);
32192   jresult = result;
32193   return jresult;
32194 }
32195
32196
32197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32198   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32199   unsigned int arg2 ;
32200
32201   arg1 = (Dali::WheelEvent *)jarg1;
32202   arg2 = (unsigned int)jarg2;
32203   if (arg1) (arg1)->modifiers = arg2;
32204 }
32205
32206
32207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32208   unsigned int jresult ;
32209   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32210   unsigned int result;
32211
32212   arg1 = (Dali::WheelEvent *)jarg1;
32213   result = (unsigned int) ((arg1)->modifiers);
32214   jresult = result;
32215   return jresult;
32216 }
32217
32218
32219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32220   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32221   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32222
32223   arg1 = (Dali::WheelEvent *)jarg1;
32224   arg2 = (Dali::Vector2 *)jarg2;
32225   if (arg1) (arg1)->point = *arg2;
32226 }
32227
32228
32229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32230   void * jresult ;
32231   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32232   Dali::Vector2 *result = 0 ;
32233
32234   arg1 = (Dali::WheelEvent *)jarg1;
32235   result = (Dali::Vector2 *)& ((arg1)->point);
32236   jresult = (void *)result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32242   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32243   int arg2 ;
32244
32245   arg1 = (Dali::WheelEvent *)jarg1;
32246   arg2 = (int)jarg2;
32247   if (arg1) (arg1)->z = arg2;
32248 }
32249
32250
32251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32252   int jresult ;
32253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32254   int result;
32255
32256   arg1 = (Dali::WheelEvent *)jarg1;
32257   result = (int) ((arg1)->z);
32258   jresult = result;
32259   return jresult;
32260 }
32261
32262
32263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32264   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32265   unsigned int arg2 ;
32266
32267   arg1 = (Dali::WheelEvent *)jarg1;
32268   arg2 = (unsigned int)jarg2;
32269   if (arg1) (arg1)->timeStamp = arg2;
32270 }
32271
32272
32273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32274   unsigned int jresult ;
32275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32276   unsigned int result;
32277
32278   arg1 = (Dali::WheelEvent *)jarg1;
32279   result = (unsigned int) ((arg1)->timeStamp);
32280   jresult = result;
32281   return jresult;
32282 }
32283
32284 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32285   char * jresult ;
32286   Dali::KeyEvent *arg1 = 0 ;
32287   std::string result;
32288
32289   arg1 = (Dali::KeyEvent *)jarg1;
32290   if (!arg1) {
32291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32292     return 0;
32293   }
32294   {
32295     try {
32296       result = arg1->GetDeviceName();
32297     } catch (std::out_of_range& e) {
32298       {
32299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32300       };
32301     } catch (std::exception& e) {
32302       {
32303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32304       };
32305     } catch (Dali::DaliException e) {
32306       {
32307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32308       };
32309     } catch (...) {
32310       {
32311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32312       };
32313     }
32314   }
32315
32316   jresult = SWIG_csharp_string_callback((&result)->c_str());
32317   return jresult;
32318 }
32319
32320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32321   int jresult ;
32322   Dali::KeyEvent *arg1 = 0 ;
32323   Dali::Device::Class::Type result;
32324
32325   arg1 = (Dali::KeyEvent *)jarg1;
32326   if (!arg1) {
32327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32328     return 0;
32329   }
32330   {
32331     try {
32332       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32333     } catch (std::out_of_range& e) {
32334       {
32335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32336       };
32337     } catch (std::exception& e) {
32338       {
32339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32340       };
32341     } catch (Dali::DaliException e) {
32342       {
32343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32344       };
32345     } catch (...) {
32346       {
32347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32348       };
32349     }
32350   }
32351
32352   jresult = (int)result;
32353   return jresult;
32354 }
32355
32356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32357   int jresult ;
32358   Dali::KeyEvent *arg1 = 0 ;
32359   Dali::Device::Subclass::Type result;
32360
32361   arg1 = (Dali::KeyEvent *)jarg1;
32362   if (!arg1) {
32363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32364     return 0;
32365   }
32366   {
32367     try {
32368       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32369     } catch (std::out_of_range& e) {
32370       {
32371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32372       };
32373     } catch (std::exception& e) {
32374       {
32375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32376       };
32377     } catch (Dali::DaliException e) {
32378       {
32379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32380       };
32381     } catch (...) {
32382       {
32383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32384       };
32385     }
32386   }
32387
32388   jresult = (int)result;
32389   return jresult;
32390 }
32391
32392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32393   Dali::Actor arg1 ;
32394   Dali::Actor *argp1 ;
32395
32396   argp1 = (Dali::Actor *)jarg1;
32397   if (!argp1) {
32398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32399     return ;
32400   }
32401   arg1 = *argp1;
32402   {
32403     try {
32404       arg1.Raise();
32405     } catch (std::out_of_range& e) {
32406       {
32407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32408       };
32409     } catch (std::exception& e) {
32410       {
32411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32412       };
32413     } catch (Dali::DaliException e) {
32414       {
32415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32416       };
32417     } catch (...) {
32418       {
32419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32420       };
32421     }
32422   }
32423
32424 }
32425
32426
32427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32428   Dali::Actor arg1 ;
32429   Dali::Actor *argp1 ;
32430
32431   argp1 = (Dali::Actor *)jarg1;
32432   if (!argp1) {
32433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32434     return ;
32435   }
32436   arg1 = *argp1;
32437   {
32438     try {
32439       arg1.Lower();
32440     } catch (std::out_of_range& e) {
32441       {
32442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32443       };
32444     } catch (std::exception& e) {
32445       {
32446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32447       };
32448     } catch (Dali::DaliException e) {
32449       {
32450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32451       };
32452     } catch (...) {
32453       {
32454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32455       };
32456     }
32457   }
32458
32459 }
32460
32461
32462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32463   Dali::Actor arg1 ;
32464   Dali::Actor *argp1 ;
32465
32466   argp1 = (Dali::Actor *)jarg1;
32467   if (!argp1) {
32468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32469     return ;
32470   }
32471   arg1 = *argp1;
32472   {
32473     try {
32474       arg1.RaiseToTop();
32475     } catch (std::out_of_range& e) {
32476       {
32477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32478       };
32479     } catch (std::exception& e) {
32480       {
32481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32482       };
32483     } catch (Dali::DaliException e) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32486       };
32487     } catch (...) {
32488       {
32489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32490       };
32491     }
32492   }
32493
32494 }
32495
32496
32497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32498   Dali::Actor arg1 ;
32499   Dali::Actor *argp1 ;
32500
32501   argp1 = (Dali::Actor *)jarg1;
32502   if (!argp1) {
32503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32504     return ;
32505   }
32506   arg1 = *argp1;
32507   {
32508     try {
32509       arg1.LowerToBottom();
32510     } catch (std::out_of_range& e) {
32511       {
32512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32513       };
32514     } catch (std::exception& e) {
32515       {
32516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32517       };
32518     } catch (Dali::DaliException e) {
32519       {
32520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32521       };
32522     } catch (...) {
32523       {
32524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32525       };
32526     }
32527   }
32528
32529 }
32530
32531
32532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32533   Dali::Actor arg1 ;
32534   Dali::Actor arg2 ;
32535   Dali::Actor *argp1 ;
32536   Dali::Actor *argp2 ;
32537
32538   argp1 = (Dali::Actor *)jarg1;
32539   if (!argp1) {
32540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32541     return ;
32542   }
32543   arg1 = *argp1;
32544   argp2 = (Dali::Actor *)jarg2;
32545   if (!argp2) {
32546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32547     return ;
32548   }
32549   arg2 = *argp2;
32550   {
32551     try {
32552       arg1.RaiseAbove(arg2);
32553     } catch (std::out_of_range& e) {
32554       {
32555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32556       };
32557     } catch (std::exception& e) {
32558       {
32559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (Dali::DaliException e) {
32562       {
32563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32564       };
32565     } catch (...) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32568       };
32569     }
32570   }
32571
32572 }
32573
32574
32575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32576   Dali::Actor arg1 ;
32577   Dali::Actor arg2 ;
32578   Dali::Actor *argp1 ;
32579   Dali::Actor *argp2 ;
32580
32581   argp1 = (Dali::Actor *)jarg1;
32582   if (!argp1) {
32583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32584     return ;
32585   }
32586   arg1 = *argp1;
32587   argp2 = (Dali::Actor *)jarg2;
32588   if (!argp2) {
32589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32590     return ;
32591   }
32592   arg2 = *argp2;
32593   {
32594     try {
32595       arg1.LowerBelow(arg2);
32596     } catch (std::out_of_range& e) {
32597       {
32598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32599       };
32600     } catch (std::exception& e) {
32601       {
32602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32603       };
32604     } catch (Dali::DaliException e) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32607       };
32608     } catch (...) {
32609       {
32610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32611       };
32612     }
32613   }
32614
32615 }
32616
32617
32618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32619   void * jresult ;
32620   Dali::Actor arg1 ;
32621   Dali::Actor *argp1 ;
32622   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32623
32624   argp1 = (Dali::Actor *)jarg1;
32625   if (!argp1) {
32626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32627     return 0;
32628   }
32629   arg1 = *argp1;
32630   {
32631     try {
32632       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32633     } catch (std::out_of_range& e) {
32634       {
32635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32636       };
32637     } catch (std::exception& e) {
32638       {
32639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32640       };
32641     } catch (Dali::DaliException e) {
32642       {
32643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32644       };
32645     } catch (...) {
32646       {
32647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32648       };
32649     }
32650   }
32651
32652   jresult = (void *)result;
32653   return jresult;
32654 }
32655
32656
32657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32658   void * jresult ;
32659   Dali::Actor *arg1 ;
32660   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32661
32662   arg1 = (Dali::Actor *)jarg1;
32663   {
32664     try {
32665       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32666     } catch (std::out_of_range& e) {
32667       {
32668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32669       };
32670     } catch (std::exception& e) {
32671       {
32672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32673       };
32674     } catch (Dali::DaliException e) {
32675       {
32676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32677       };
32678     } catch (...) {
32679       {
32680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32681       };
32682     }
32683   }
32684
32685   jresult = (void *)result;
32686   return jresult;
32687 }
32688
32689
32690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32691   int jresult ;
32692   int result;
32693
32694   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32695   jresult = (int)result;
32696   return jresult;
32697 }
32698
32699
32700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32701   int jresult ;
32702   int result;
32703
32704   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32705   jresult = (int)result;
32706   return jresult;
32707 }
32708
32709
32710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32711   int jresult ;
32712   int result;
32713
32714   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32715   jresult = (int)result;
32716   return jresult;
32717 }
32718
32719
32720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32721   int jresult ;
32722   int result;
32723
32724   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32725   jresult = (int)result;
32726   return jresult;
32727 }
32728
32729
32730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32731   int jresult ;
32732   int result;
32733
32734   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32735   jresult = (int)result;
32736   return jresult;
32737 }
32738
32739
32740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32741   int jresult ;
32742   int result;
32743
32744   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32745   jresult = (int)result;
32746   return jresult;
32747 }
32748
32749
32750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32751   int jresult ;
32752   int result;
32753
32754   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32755   jresult = (int)result;
32756   return jresult;
32757 }
32758
32759
32760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32761   int jresult ;
32762   int result;
32763
32764   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32765   jresult = (int)result;
32766   return jresult;
32767 }
32768
32769
32770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32771   int jresult ;
32772   int result;
32773
32774   result = (int)Dali::Actor::Property::SIZE;
32775   jresult = (int)result;
32776   return jresult;
32777 }
32778
32779
32780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32781   int jresult ;
32782   int result;
32783
32784   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32785   jresult = (int)result;
32786   return jresult;
32787 }
32788
32789
32790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32791   int jresult ;
32792   int result;
32793
32794   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32795   jresult = (int)result;
32796   return jresult;
32797 }
32798
32799
32800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32801   int jresult ;
32802   int result;
32803
32804   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32805   jresult = (int)result;
32806   return jresult;
32807 }
32808
32809
32810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32811   int jresult ;
32812   int result;
32813
32814   result = (int)Dali::Actor::Property::POSITION;
32815   jresult = (int)result;
32816   return jresult;
32817 }
32818
32819
32820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32821   int jresult ;
32822   int result;
32823
32824   result = (int)Dali::Actor::Property::POSITION_X;
32825   jresult = (int)result;
32826   return jresult;
32827 }
32828
32829
32830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32831   int jresult ;
32832   int result;
32833
32834   result = (int)Dali::Actor::Property::POSITION_Y;
32835   jresult = (int)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::POSITION_Z;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::WORLD_POSITION;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::ORIENTATION;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::SCALE;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::SCALE_X;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::SCALE_Y;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::SCALE_Z;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::WORLD_SCALE;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::VISIBLE;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::COLOR;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::COLOR_RED;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::COLOR_GREEN;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::COLOR_BLUE;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::WORLD_COLOR;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::NAME;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::SENSITIVE;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::COLOR_MODE;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::DRAW_MODE;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::PADDING;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33231   void * jresult ;
33232   Dali::Actor::Property *result = 0 ;
33233
33234   {
33235     try {
33236       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33237     } catch (std::out_of_range& e) {
33238       {
33239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33240       };
33241     } catch (std::exception& e) {
33242       {
33243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33244       };
33245     } catch (Dali::DaliException e) {
33246       {
33247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33248       };
33249     } catch (...) {
33250       {
33251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33252       };
33253     }
33254   }
33255
33256   jresult = (void *)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33262   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33263
33264   arg1 = (Dali::Actor::Property *)jarg1;
33265   {
33266     try {
33267       delete arg1;
33268     } catch (std::out_of_range& e) {
33269       {
33270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33271       };
33272     } catch (std::exception& e) {
33273       {
33274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33275       };
33276     } catch (Dali::DaliException e) {
33277       {
33278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33279       };
33280     } catch (...) {
33281       {
33282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33283       };
33284     }
33285   }
33286
33287 }
33288
33289
33290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33291   void * jresult ;
33292   Dali::Actor *result = 0 ;
33293
33294   {
33295     try {
33296       result = (Dali::Actor *)new Dali::Actor();
33297     } catch (std::out_of_range& e) {
33298       {
33299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33300       };
33301     } catch (std::exception& e) {
33302       {
33303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33304       };
33305     } catch (Dali::DaliException e) {
33306       {
33307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33308       };
33309     } catch (...) {
33310       {
33311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33312       };
33313     }
33314   }
33315
33316   jresult = (void *)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33322   void * jresult ;
33323   Dali::Actor result;
33324
33325   {
33326     try {
33327       result = Dali::Actor::New();
33328     } catch (std::out_of_range& e) {
33329       {
33330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33331       };
33332     } catch (std::exception& e) {
33333       {
33334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33335       };
33336     } catch (Dali::DaliException e) {
33337       {
33338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33339       };
33340     } catch (...) {
33341       {
33342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33343       };
33344     }
33345   }
33346
33347   jresult = new Dali::Actor((const Dali::Actor &)result);
33348   return jresult;
33349 }
33350
33351
33352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33353   void * jresult ;
33354   Dali::BaseHandle arg1 ;
33355   Dali::BaseHandle *argp1 ;
33356   Dali::Actor result;
33357
33358   argp1 = (Dali::BaseHandle *)jarg1;
33359   if (!argp1) {
33360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33361     return 0;
33362   }
33363   arg1 = *argp1;
33364   {
33365     try {
33366       result = Dali::Actor::DownCast(arg1);
33367     } catch (std::out_of_range& e) {
33368       {
33369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33370       };
33371     } catch (std::exception& e) {
33372       {
33373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33374       };
33375     } catch (Dali::DaliException e) {
33376       {
33377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33378       };
33379     } catch (...) {
33380       {
33381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33382       };
33383     }
33384   }
33385
33386   jresult = new Dali::Actor((const Dali::Actor &)result);
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33393
33394   arg1 = (Dali::Actor *)jarg1;
33395   {
33396     try {
33397       delete arg1;
33398     } catch (std::out_of_range& e) {
33399       {
33400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33401       };
33402     } catch (std::exception& e) {
33403       {
33404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33405       };
33406     } catch (Dali::DaliException e) {
33407       {
33408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33409       };
33410     } catch (...) {
33411       {
33412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33413       };
33414     }
33415   }
33416
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33421   void * jresult ;
33422   Dali::Actor *arg1 = 0 ;
33423   Dali::Actor *result = 0 ;
33424
33425   arg1 = (Dali::Actor *)jarg1;
33426   if (!arg1) {
33427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33428     return 0;
33429   }
33430   {
33431     try {
33432       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33433     } catch (std::out_of_range& e) {
33434       {
33435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33436       };
33437     } catch (std::exception& e) {
33438       {
33439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33440       };
33441     } catch (Dali::DaliException e) {
33442       {
33443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33444       };
33445     } catch (...) {
33446       {
33447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33448       };
33449     }
33450   }
33451
33452   jresult = (void *)result;
33453   return jresult;
33454 }
33455
33456
33457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33458   void * jresult ;
33459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33460   Dali::Actor *arg2 = 0 ;
33461   Dali::Actor *result = 0 ;
33462
33463   arg1 = (Dali::Actor *)jarg1;
33464   arg2 = (Dali::Actor *)jarg2;
33465   if (!arg2) {
33466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33467     return 0;
33468   }
33469   {
33470     try {
33471       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33472     } catch (std::out_of_range& e) {
33473       {
33474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (std::exception& e) {
33477       {
33478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (Dali::DaliException e) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33483       };
33484     } catch (...) {
33485       {
33486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33487       };
33488     }
33489   }
33490
33491   jresult = (void *)result;
33492   return jresult;
33493 }
33494
33495
33496 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33497   char * jresult ;
33498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33499   std::string *result = 0 ;
33500
33501   arg1 = (Dali::Actor *)jarg1;
33502   {
33503     try {
33504       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33505     } catch (std::out_of_range& e) {
33506       {
33507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33508       };
33509     } catch (std::exception& e) {
33510       {
33511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33512       };
33513     } catch (Dali::DaliException e) {
33514       {
33515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33516       };
33517     } catch (...) {
33518       {
33519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33520       };
33521     }
33522   }
33523
33524   jresult = SWIG_csharp_string_callback(result->c_str());
33525   return jresult;
33526 }
33527
33528
33529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33531   std::string *arg2 = 0 ;
33532
33533   arg1 = (Dali::Actor *)jarg1;
33534   if (!jarg2) {
33535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33536     return ;
33537   }
33538   std::string arg2_str(jarg2);
33539   arg2 = &arg2_str;
33540   {
33541     try {
33542       (arg1)->SetName((std::string const &)*arg2);
33543     } catch (std::out_of_range& e) {
33544       {
33545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33546       };
33547     } catch (std::exception& e) {
33548       {
33549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33550       };
33551     } catch (Dali::DaliException e) {
33552       {
33553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33554       };
33555     } catch (...) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33558       };
33559     }
33560   }
33561
33562
33563   //argout typemap for const std::string&
33564
33565 }
33566
33567
33568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33569   unsigned int jresult ;
33570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33571   unsigned int result;
33572
33573   arg1 = (Dali::Actor *)jarg1;
33574   {
33575     try {
33576       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (Dali::DaliException e) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595
33596   jresult = result;
33597   return jresult;
33598 }
33599
33600
33601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33602   unsigned int jresult ;
33603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33604   bool result;
33605
33606   arg1 = (Dali::Actor *)jarg1;
33607   {
33608     try {
33609       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33610     } catch (std::out_of_range& e) {
33611       {
33612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33613       };
33614     } catch (std::exception& e) {
33615       {
33616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33617       };
33618     } catch (Dali::DaliException e) {
33619       {
33620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33625       };
33626     }
33627   }
33628
33629   jresult = result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33635   unsigned int jresult ;
33636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33637   bool result;
33638
33639   arg1 = (Dali::Actor *)jarg1;
33640   {
33641     try {
33642       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33643     } catch (std::out_of_range& e) {
33644       {
33645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33646       };
33647     } catch (std::exception& e) {
33648       {
33649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (Dali::DaliException e) {
33652       {
33653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33658       };
33659     }
33660   }
33661
33662   jresult = result;
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33668   unsigned int jresult ;
33669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33670   bool result;
33671
33672   arg1 = (Dali::Actor *)jarg1;
33673   {
33674     try {
33675       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (Dali::DaliException e) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33687       };
33688     } catch (...) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33691       };
33692     }
33693   }
33694
33695   jresult = result;
33696   return jresult;
33697 }
33698
33699
33700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33701   void * jresult ;
33702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33703   Dali::Layer result;
33704
33705   arg1 = (Dali::Actor *)jarg1;
33706   {
33707     try {
33708       result = (arg1)->GetLayer();
33709     } catch (std::out_of_range& e) {
33710       {
33711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33712       };
33713     } catch (std::exception& e) {
33714       {
33715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33716       };
33717     } catch (Dali::DaliException e) {
33718       {
33719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33720       };
33721     } catch (...) {
33722       {
33723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33724       };
33725     }
33726   }
33727
33728   jresult = new Dali::Layer((const Dali::Layer &)result);
33729   return jresult;
33730 }
33731
33732
33733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33735   Dali::Actor arg2 ;
33736   Dali::Actor *argp2 ;
33737
33738   arg1 = (Dali::Actor *)jarg1;
33739   argp2 = (Dali::Actor *)jarg2;
33740   if (!argp2) {
33741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33742     return ;
33743   }
33744   arg2 = *argp2;
33745   {
33746     try {
33747       (arg1)->Add(arg2);
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33755       };
33756     } catch (Dali::DaliException e) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33759       };
33760     } catch (...) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33763       };
33764     }
33765   }
33766
33767 }
33768
33769
33770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33772   Dali::Actor arg2 ;
33773   Dali::Actor *argp2 ;
33774
33775   arg1 = (Dali::Actor *)jarg1;
33776   argp2 = (Dali::Actor *)jarg2;
33777   if (!argp2) {
33778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33779     return ;
33780   }
33781   arg2 = *argp2;
33782   {
33783     try {
33784       (arg1)->Remove(arg2);
33785     } catch (std::out_of_range& e) {
33786       {
33787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33788       };
33789     } catch (std::exception& e) {
33790       {
33791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33792       };
33793     } catch (Dali::DaliException e) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33800       };
33801     }
33802   }
33803
33804 }
33805
33806
33807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33809
33810   arg1 = (Dali::Actor *)jarg1;
33811   {
33812     try {
33813       (arg1)->Unparent();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33829       };
33830     }
33831   }
33832
33833 }
33834
33835
33836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33837   unsigned int jresult ;
33838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33839   unsigned int result;
33840
33841   arg1 = (Dali::Actor *)jarg1;
33842   {
33843     try {
33844       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33845     } catch (std::out_of_range& e) {
33846       {
33847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33848       };
33849     } catch (std::exception& e) {
33850       {
33851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (Dali::DaliException e) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33860       };
33861     }
33862   }
33863
33864   jresult = result;
33865   return jresult;
33866 }
33867
33868
33869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33870   void * jresult ;
33871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33872   unsigned int arg2 ;
33873   Dali::Actor result;
33874
33875   arg1 = (Dali::Actor *)jarg1;
33876   arg2 = (unsigned int)jarg2;
33877   {
33878     try {
33879       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (Dali::DaliException e) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33891       };
33892     } catch (...) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33895       };
33896     }
33897   }
33898
33899   jresult = new Dali::Actor((const Dali::Actor &)result);
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33905   void * jresult ;
33906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33907   std::string *arg2 = 0 ;
33908   Dali::Actor result;
33909
33910   arg1 = (Dali::Actor *)jarg1;
33911   if (!jarg2) {
33912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33913     return 0;
33914   }
33915   std::string arg2_str(jarg2);
33916   arg2 = &arg2_str;
33917   {
33918     try {
33919       result = (arg1)->FindChildByName((std::string const &)*arg2);
33920     } catch (std::out_of_range& e) {
33921       {
33922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33923       };
33924     } catch (std::exception& e) {
33925       {
33926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33927       };
33928     } catch (Dali::DaliException e) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33931       };
33932     } catch (...) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33935       };
33936     }
33937   }
33938
33939   jresult = new Dali::Actor((const Dali::Actor &)result);
33940
33941   //argout typemap for const std::string&
33942
33943   return jresult;
33944 }
33945
33946
33947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33948   void * jresult ;
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950   unsigned int arg2 ;
33951   Dali::Actor result;
33952
33953   arg1 = (Dali::Actor *)jarg1;
33954   arg2 = (unsigned int)jarg2;
33955   {
33956     try {
33957       result = (arg1)->FindChildById(arg2);
33958     } catch (std::out_of_range& e) {
33959       {
33960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33961       };
33962     } catch (std::exception& e) {
33963       {
33964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33965       };
33966     } catch (Dali::DaliException e) {
33967       {
33968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33969       };
33970     } catch (...) {
33971       {
33972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33973       };
33974     }
33975   }
33976
33977   jresult = new Dali::Actor((const Dali::Actor &)result);
33978   return jresult;
33979 }
33980
33981
33982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33983   void * jresult ;
33984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33985   Dali::Actor result;
33986
33987   arg1 = (Dali::Actor *)jarg1;
33988   {
33989     try {
33990       result = ((Dali::Actor const *)arg1)->GetParent();
33991     } catch (std::out_of_range& e) {
33992       {
33993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (std::exception& e) {
33996       {
33997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33998       };
33999     } catch (Dali::DaliException e) {
34000       {
34001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34002       };
34003     } catch (...) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34006       };
34007     }
34008   }
34009
34010   jresult = new Dali::Actor((const Dali::Actor &)result);
34011   return jresult;
34012 }
34013
34014
34015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34017   Dali::Vector3 *arg2 = 0 ;
34018
34019   arg1 = (Dali::Actor *)jarg1;
34020   arg2 = (Dali::Vector3 *)jarg2;
34021   if (!arg2) {
34022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34023     return ;
34024   }
34025   {
34026     try {
34027       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34028     } catch (std::out_of_range& e) {
34029       {
34030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34031       };
34032     } catch (std::exception& e) {
34033       {
34034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34035       };
34036     } catch (Dali::DaliException e) {
34037       {
34038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34039       };
34040     } catch (...) {
34041       {
34042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34043       };
34044     }
34045   }
34046
34047 }
34048
34049
34050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34051   void * jresult ;
34052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34053   Dali::Vector3 result;
34054
34055   arg1 = (Dali::Actor *)jarg1;
34056   {
34057     try {
34058       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (Dali::DaliException e) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077
34078   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34079   return jresult;
34080 }
34081
34082
34083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34085   Dali::Vector3 *arg2 = 0 ;
34086
34087   arg1 = (Dali::Actor *)jarg1;
34088   arg2 = (Dali::Vector3 *)jarg2;
34089   if (!arg2) {
34090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34091     return ;
34092   }
34093   {
34094     try {
34095       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34096     } catch (std::out_of_range& e) {
34097       {
34098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34099       };
34100     } catch (std::exception& e) {
34101       {
34102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34103       };
34104     } catch (Dali::DaliException e) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34107       };
34108     } catch (...) {
34109       {
34110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34111       };
34112     }
34113   }
34114
34115 }
34116
34117
34118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34119   void * jresult ;
34120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34121   Dali::Vector3 result;
34122
34123   arg1 = (Dali::Actor *)jarg1;
34124   {
34125     try {
34126       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (Dali::DaliException e) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34138       };
34139     } catch (...) {
34140       {
34141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34142       };
34143     }
34144   }
34145
34146   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34147   return jresult;
34148 }
34149
34150
34151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34153   float arg2 ;
34154   float arg3 ;
34155
34156   arg1 = (Dali::Actor *)jarg1;
34157   arg2 = (float)jarg2;
34158   arg3 = (float)jarg3;
34159   {
34160     try {
34161       (arg1)->SetSize(arg2,arg3);
34162     } catch (std::out_of_range& e) {
34163       {
34164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34165       };
34166     } catch (std::exception& e) {
34167       {
34168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34169       };
34170     } catch (Dali::DaliException e) {
34171       {
34172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34173       };
34174     } catch (...) {
34175       {
34176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34177       };
34178     }
34179   }
34180
34181 }
34182
34183
34184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34186   float arg2 ;
34187   float arg3 ;
34188   float arg4 ;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (float)jarg2;
34192   arg3 = (float)jarg3;
34193   arg4 = (float)jarg4;
34194   {
34195     try {
34196       (arg1)->SetSize(arg2,arg3,arg4);
34197     } catch (std::out_of_range& e) {
34198       {
34199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34200       };
34201     } catch (std::exception& e) {
34202       {
34203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34204       };
34205     } catch (Dali::DaliException e) {
34206       {
34207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34208       };
34209     } catch (...) {
34210       {
34211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34212       };
34213     }
34214   }
34215
34216 }
34217
34218
34219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34221   Dali::Vector2 *arg2 = 0 ;
34222
34223   arg1 = (Dali::Actor *)jarg1;
34224   arg2 = (Dali::Vector2 *)jarg2;
34225   if (!arg2) {
34226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34227     return ;
34228   }
34229   {
34230     try {
34231       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34232     } catch (std::out_of_range& e) {
34233       {
34234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34235       };
34236     } catch (std::exception& e) {
34237       {
34238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34239       };
34240     } catch (Dali::DaliException e) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34243       };
34244     } catch (...) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34247       };
34248     }
34249   }
34250
34251 }
34252
34253
34254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34256   Dali::Vector3 *arg2 = 0 ;
34257
34258   arg1 = (Dali::Actor *)jarg1;
34259   arg2 = (Dali::Vector3 *)jarg2;
34260   if (!arg2) {
34261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34262     return ;
34263   }
34264   {
34265     try {
34266       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (Dali::DaliException e) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285
34286 }
34287
34288
34289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34290   void * jresult ;
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   Dali::Vector3 result;
34293
34294   arg1 = (Dali::Actor *)jarg1;
34295   {
34296     try {
34297       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34298     } catch (std::out_of_range& e) {
34299       {
34300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34301       };
34302     } catch (std::exception& e) {
34303       {
34304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34305       };
34306     } catch (Dali::DaliException e) {
34307       {
34308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34309       };
34310     } catch (...) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34313       };
34314     }
34315   }
34316
34317   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34318   return jresult;
34319 }
34320
34321
34322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34323   void * jresult ;
34324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34325   Dali::Vector3 result;
34326
34327   arg1 = (Dali::Actor *)jarg1;
34328   {
34329     try {
34330       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34331     } catch (std::out_of_range& e) {
34332       {
34333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34334       };
34335     } catch (std::exception& e) {
34336       {
34337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34338       };
34339     } catch (Dali::DaliException e) {
34340       {
34341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34342       };
34343     } catch (...) {
34344       {
34345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34346       };
34347     }
34348   }
34349
34350   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34351   return jresult;
34352 }
34353
34354
34355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34356   void * jresult ;
34357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34358   Dali::Vector3 result;
34359
34360   arg1 = (Dali::Actor *)jarg1;
34361   {
34362     try {
34363       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34371       };
34372     } catch (Dali::DaliException e) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34375       };
34376     } catch (...) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34379       };
34380     }
34381   }
34382
34383   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34384   return jresult;
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   float arg2 ;
34391   float arg3 ;
34392
34393   arg1 = (Dali::Actor *)jarg1;
34394   arg2 = (float)jarg2;
34395   arg3 = (float)jarg3;
34396   {
34397     try {
34398       (arg1)->SetPosition(arg2,arg3);
34399     } catch (std::out_of_range& e) {
34400       {
34401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34402       };
34403     } catch (std::exception& e) {
34404       {
34405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34406       };
34407     } catch (Dali::DaliException e) {
34408       {
34409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34410       };
34411     } catch (...) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34414       };
34415     }
34416   }
34417
34418 }
34419
34420
34421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34423   float arg2 ;
34424   float arg3 ;
34425   float arg4 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (float)jarg2;
34429   arg3 = (float)jarg3;
34430   arg4 = (float)jarg4;
34431   {
34432     try {
34433       (arg1)->SetPosition(arg2,arg3,arg4);
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (Dali::DaliException e) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34449       };
34450     }
34451   }
34452
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34458   Dali::Vector3 *arg2 = 0 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (Dali::Vector3 *)jarg2;
34462   if (!arg2) {
34463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34464     return ;
34465   }
34466   {
34467     try {
34468       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34469     } catch (std::out_of_range& e) {
34470       {
34471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34472       };
34473     } catch (std::exception& e) {
34474       {
34475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34476       };
34477     } catch (Dali::DaliException e) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34480       };
34481     } catch (...) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34484       };
34485     }
34486   }
34487
34488 }
34489
34490
34491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34493   float arg2 ;
34494
34495   arg1 = (Dali::Actor *)jarg1;
34496   arg2 = (float)jarg2;
34497   {
34498     try {
34499       (arg1)->SetX(arg2);
34500     } catch (std::out_of_range& e) {
34501       {
34502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34503       };
34504     } catch (std::exception& e) {
34505       {
34506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (Dali::DaliException e) {
34509       {
34510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34511       };
34512     } catch (...) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34515       };
34516     }
34517   }
34518
34519 }
34520
34521
34522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34524   float arg2 ;
34525
34526   arg1 = (Dali::Actor *)jarg1;
34527   arg2 = (float)jarg2;
34528   {
34529     try {
34530       (arg1)->SetY(arg2);
34531     } catch (std::out_of_range& e) {
34532       {
34533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34534       };
34535     } catch (std::exception& e) {
34536       {
34537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34538       };
34539     } catch (Dali::DaliException e) {
34540       {
34541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34542       };
34543     } catch (...) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34546       };
34547     }
34548   }
34549
34550 }
34551
34552
34553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34555   float arg2 ;
34556
34557   arg1 = (Dali::Actor *)jarg1;
34558   arg2 = (float)jarg2;
34559   {
34560     try {
34561       (arg1)->SetZ(arg2);
34562     } catch (std::out_of_range& e) {
34563       {
34564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34565       };
34566     } catch (std::exception& e) {
34567       {
34568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34569       };
34570     } catch (Dali::DaliException e) {
34571       {
34572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34573       };
34574     } catch (...) {
34575       {
34576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34577       };
34578     }
34579   }
34580
34581 }
34582
34583
34584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34586   Dali::Vector3 *arg2 = 0 ;
34587
34588   arg1 = (Dali::Actor *)jarg1;
34589   arg2 = (Dali::Vector3 *)jarg2;
34590   if (!arg2) {
34591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34592     return ;
34593   }
34594   {
34595     try {
34596       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34597     } catch (std::out_of_range& e) {
34598       {
34599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34600       };
34601     } catch (std::exception& e) {
34602       {
34603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34604       };
34605     } catch (Dali::DaliException e) {
34606       {
34607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34608       };
34609     } catch (...) {
34610       {
34611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34612       };
34613     }
34614   }
34615
34616 }
34617
34618
34619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34620   void * jresult ;
34621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34622   Dali::Vector3 result;
34623
34624   arg1 = (Dali::Actor *)jarg1;
34625   {
34626     try {
34627       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34628     } catch (std::out_of_range& e) {
34629       {
34630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34631       };
34632     } catch (std::exception& e) {
34633       {
34634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34635       };
34636     } catch (Dali::DaliException e) {
34637       {
34638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34639       };
34640     } catch (...) {
34641       {
34642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34643       };
34644     }
34645   }
34646
34647   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34648   return jresult;
34649 }
34650
34651
34652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34653   void * jresult ;
34654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34655   Dali::Vector3 result;
34656
34657   arg1 = (Dali::Actor *)jarg1;
34658   {
34659     try {
34660       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34661     } catch (std::out_of_range& e) {
34662       {
34663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34664       };
34665     } catch (std::exception& e) {
34666       {
34667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34668       };
34669     } catch (Dali::DaliException e) {
34670       {
34671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34672       };
34673     } catch (...) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34676       };
34677     }
34678   }
34679
34680   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34681   return jresult;
34682 }
34683
34684
34685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34687   bool arg2 ;
34688
34689   arg1 = (Dali::Actor *)jarg1;
34690   arg2 = jarg2 ? true : false;
34691   {
34692     try {
34693       (arg1)->SetInheritPosition(arg2);
34694     } catch (std::out_of_range& e) {
34695       {
34696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34697       };
34698     } catch (std::exception& e) {
34699       {
34700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34701       };
34702     } catch (Dali::DaliException e) {
34703       {
34704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34705       };
34706     } catch (...) {
34707       {
34708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34709       };
34710     }
34711   }
34712
34713 }
34714
34715
34716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34717   int jresult ;
34718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34719   Dali::PositionInheritanceMode result;
34720
34721   arg1 = (Dali::Actor *)jarg1;
34722   {
34723     try {
34724       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34725     } catch (std::out_of_range& e) {
34726       {
34727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34728       };
34729     } catch (std::exception& e) {
34730       {
34731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34732       };
34733     } catch (Dali::DaliException e) {
34734       {
34735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34736       };
34737     } catch (...) {
34738       {
34739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34740       };
34741     }
34742   }
34743
34744   jresult = (int)result;
34745   return jresult;
34746 }
34747
34748
34749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34750   unsigned int jresult ;
34751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34752   bool result;
34753
34754   arg1 = (Dali::Actor *)jarg1;
34755   {
34756     try {
34757       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34758     } catch (std::out_of_range& e) {
34759       {
34760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34761       };
34762     } catch (std::exception& e) {
34763       {
34764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34765       };
34766     } catch (Dali::DaliException e) {
34767       {
34768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34769       };
34770     } catch (...) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34773       };
34774     }
34775   }
34776
34777   jresult = result;
34778   return jresult;
34779 }
34780
34781
34782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34784   Dali::Degree *arg2 = 0 ;
34785   Dali::Vector3 *arg3 = 0 ;
34786
34787   arg1 = (Dali::Actor *)jarg1;
34788   arg2 = (Dali::Degree *)jarg2;
34789   if (!arg2) {
34790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34791     return ;
34792   }
34793   arg3 = (Dali::Vector3 *)jarg3;
34794   if (!arg3) {
34795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34796     return ;
34797   }
34798   {
34799     try {
34800       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34801     } catch (std::out_of_range& e) {
34802       {
34803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34804       };
34805     } catch (std::exception& e) {
34806       {
34807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34808       };
34809     } catch (Dali::DaliException e) {
34810       {
34811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34812       };
34813     } catch (...) {
34814       {
34815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34816       };
34817     }
34818   }
34819
34820 }
34821
34822
34823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34825   Dali::Radian *arg2 = 0 ;
34826   Dali::Vector3 *arg3 = 0 ;
34827
34828   arg1 = (Dali::Actor *)jarg1;
34829   arg2 = (Dali::Radian *)jarg2;
34830   if (!arg2) {
34831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34832     return ;
34833   }
34834   arg3 = (Dali::Vector3 *)jarg3;
34835   if (!arg3) {
34836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34837     return ;
34838   }
34839   {
34840     try {
34841       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34842     } catch (std::out_of_range& e) {
34843       {
34844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34845       };
34846     } catch (std::exception& e) {
34847       {
34848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34849       };
34850     } catch (Dali::DaliException e) {
34851       {
34852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34853       };
34854     } catch (...) {
34855       {
34856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34857       };
34858     }
34859   }
34860
34861 }
34862
34863
34864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34866   Dali::Quaternion *arg2 = 0 ;
34867
34868   arg1 = (Dali::Actor *)jarg1;
34869   arg2 = (Dali::Quaternion *)jarg2;
34870   if (!arg2) {
34871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34872     return ;
34873   }
34874   {
34875     try {
34876       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34877     } catch (std::out_of_range& e) {
34878       {
34879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34880       };
34881     } catch (std::exception& e) {
34882       {
34883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34884       };
34885     } catch (Dali::DaliException e) {
34886       {
34887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34888       };
34889     } catch (...) {
34890       {
34891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34892       };
34893     }
34894   }
34895
34896 }
34897
34898
34899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34901   Dali::Degree *arg2 = 0 ;
34902   Dali::Vector3 *arg3 = 0 ;
34903
34904   arg1 = (Dali::Actor *)jarg1;
34905   arg2 = (Dali::Degree *)jarg2;
34906   if (!arg2) {
34907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34908     return ;
34909   }
34910   arg3 = (Dali::Vector3 *)jarg3;
34911   if (!arg3) {
34912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34913     return ;
34914   }
34915   {
34916     try {
34917       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34918     } catch (std::out_of_range& e) {
34919       {
34920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34921       };
34922     } catch (std::exception& e) {
34923       {
34924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34925       };
34926     } catch (Dali::DaliException e) {
34927       {
34928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34929       };
34930     } catch (...) {
34931       {
34932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34933       };
34934     }
34935   }
34936
34937 }
34938
34939
34940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34942   Dali::Radian *arg2 = 0 ;
34943   Dali::Vector3 *arg3 = 0 ;
34944
34945   arg1 = (Dali::Actor *)jarg1;
34946   arg2 = (Dali::Radian *)jarg2;
34947   if (!arg2) {
34948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34949     return ;
34950   }
34951   arg3 = (Dali::Vector3 *)jarg3;
34952   if (!arg3) {
34953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34954     return ;
34955   }
34956   {
34957     try {
34958       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34966       };
34967     } catch (Dali::DaliException e) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34970       };
34971     } catch (...) {
34972       {
34973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34974       };
34975     }
34976   }
34977
34978 }
34979
34980
34981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34983   Dali::Quaternion *arg2 = 0 ;
34984
34985   arg1 = (Dali::Actor *)jarg1;
34986   arg2 = (Dali::Quaternion *)jarg2;
34987   if (!arg2) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34989     return ;
34990   }
34991   {
34992     try {
34993       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34994     } catch (std::out_of_range& e) {
34995       {
34996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34997       };
34998     } catch (std::exception& e) {
34999       {
35000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35001       };
35002     } catch (Dali::DaliException e) {
35003       {
35004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35005       };
35006     } catch (...) {
35007       {
35008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35009       };
35010     }
35011   }
35012
35013 }
35014
35015
35016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35017   void * jresult ;
35018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35019   Dali::Quaternion result;
35020
35021   arg1 = (Dali::Actor *)jarg1;
35022   {
35023     try {
35024       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35025     } catch (std::out_of_range& e) {
35026       {
35027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35028       };
35029     } catch (std::exception& e) {
35030       {
35031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35032       };
35033     } catch (Dali::DaliException e) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35036       };
35037     } catch (...) {
35038       {
35039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35040       };
35041     }
35042   }
35043
35044   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35045   return jresult;
35046 }
35047
35048
35049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35051   bool arg2 ;
35052
35053   arg1 = (Dali::Actor *)jarg1;
35054   arg2 = jarg2 ? true : false;
35055   {
35056     try {
35057       (arg1)->SetInheritOrientation(arg2);
35058     } catch (std::out_of_range& e) {
35059       {
35060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35061       };
35062     } catch (std::exception& e) {
35063       {
35064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35065       };
35066     } catch (Dali::DaliException e) {
35067       {
35068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35069       };
35070     } catch (...) {
35071       {
35072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35073       };
35074     }
35075   }
35076
35077 }
35078
35079
35080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35081   unsigned int jresult ;
35082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35083   bool result;
35084
35085   arg1 = (Dali::Actor *)jarg1;
35086   {
35087     try {
35088       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35089     } catch (std::out_of_range& e) {
35090       {
35091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35092       };
35093     } catch (std::exception& e) {
35094       {
35095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35096       };
35097     } catch (Dali::DaliException e) {
35098       {
35099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35100       };
35101     } catch (...) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35104       };
35105     }
35106   }
35107
35108   jresult = result;
35109   return jresult;
35110 }
35111
35112
35113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35114   void * jresult ;
35115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35116   Dali::Quaternion result;
35117
35118   arg1 = (Dali::Actor *)jarg1;
35119   {
35120     try {
35121       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35122     } catch (std::out_of_range& e) {
35123       {
35124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35125       };
35126     } catch (std::exception& e) {
35127       {
35128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35129       };
35130     } catch (Dali::DaliException e) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35133       };
35134     } catch (...) {
35135       {
35136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35137       };
35138     }
35139   }
35140
35141   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35142   return jresult;
35143 }
35144
35145
35146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35148   float arg2 ;
35149
35150   arg1 = (Dali::Actor *)jarg1;
35151   arg2 = (float)jarg2;
35152   {
35153     try {
35154       (arg1)->SetScale(arg2);
35155     } catch (std::out_of_range& e) {
35156       {
35157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35158       };
35159     } catch (std::exception& e) {
35160       {
35161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35162       };
35163     } catch (Dali::DaliException e) {
35164       {
35165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35166       };
35167     } catch (...) {
35168       {
35169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35170       };
35171     }
35172   }
35173
35174 }
35175
35176
35177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35179   float arg2 ;
35180   float arg3 ;
35181   float arg4 ;
35182
35183   arg1 = (Dali::Actor *)jarg1;
35184   arg2 = (float)jarg2;
35185   arg3 = (float)jarg3;
35186   arg4 = (float)jarg4;
35187   {
35188     try {
35189       (arg1)->SetScale(arg2,arg3,arg4);
35190     } catch (std::out_of_range& e) {
35191       {
35192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35193       };
35194     } catch (std::exception& e) {
35195       {
35196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35197       };
35198     } catch (Dali::DaliException e) {
35199       {
35200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35201       };
35202     } catch (...) {
35203       {
35204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35205       };
35206     }
35207   }
35208
35209 }
35210
35211
35212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35214   Dali::Vector3 *arg2 = 0 ;
35215
35216   arg1 = (Dali::Actor *)jarg1;
35217   arg2 = (Dali::Vector3 *)jarg2;
35218   if (!arg2) {
35219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35220     return ;
35221   }
35222   {
35223     try {
35224       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35225     } catch (std::out_of_range& e) {
35226       {
35227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35228       };
35229     } catch (std::exception& e) {
35230       {
35231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35232       };
35233     } catch (Dali::DaliException e) {
35234       {
35235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35236       };
35237     } catch (...) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35240       };
35241     }
35242   }
35243
35244 }
35245
35246
35247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35249   Dali::Vector3 *arg2 = 0 ;
35250
35251   arg1 = (Dali::Actor *)jarg1;
35252   arg2 = (Dali::Vector3 *)jarg2;
35253   if (!arg2) {
35254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35255     return ;
35256   }
35257   {
35258     try {
35259       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35260     } catch (std::out_of_range& e) {
35261       {
35262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (std::exception& e) {
35265       {
35266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35267       };
35268     } catch (Dali::DaliException e) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35271       };
35272     } catch (...) {
35273       {
35274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35275       };
35276     }
35277   }
35278
35279 }
35280
35281
35282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35283   void * jresult ;
35284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35285   Dali::Vector3 result;
35286
35287   arg1 = (Dali::Actor *)jarg1;
35288   {
35289     try {
35290       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35291     } catch (std::out_of_range& e) {
35292       {
35293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35294       };
35295     } catch (std::exception& e) {
35296       {
35297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35298       };
35299     } catch (Dali::DaliException e) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35302       };
35303     } catch (...) {
35304       {
35305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35306       };
35307     }
35308   }
35309
35310   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35311   return jresult;
35312 }
35313
35314
35315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35316   void * jresult ;
35317   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35318   Dali::Vector3 result;
35319
35320   arg1 = (Dali::Actor *)jarg1;
35321   {
35322     try {
35323       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35324     } catch (std::out_of_range& e) {
35325       {
35326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35327       };
35328     } catch (std::exception& e) {
35329       {
35330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35331       };
35332     } catch (Dali::DaliException e) {
35333       {
35334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35335       };
35336     } catch (...) {
35337       {
35338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35339       };
35340     }
35341   }
35342
35343   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35344   return jresult;
35345 }
35346
35347
35348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35350   bool arg2 ;
35351
35352   arg1 = (Dali::Actor *)jarg1;
35353   arg2 = jarg2 ? true : false;
35354   {
35355     try {
35356       (arg1)->SetInheritScale(arg2);
35357     } catch (std::out_of_range& e) {
35358       {
35359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35360       };
35361     } catch (std::exception& e) {
35362       {
35363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35364       };
35365     } catch (Dali::DaliException e) {
35366       {
35367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35368       };
35369     } catch (...) {
35370       {
35371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35372       };
35373     }
35374   }
35375
35376 }
35377
35378
35379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35380   unsigned int jresult ;
35381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35382   bool result;
35383
35384   arg1 = (Dali::Actor *)jarg1;
35385   {
35386     try {
35387       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35388     } catch (std::out_of_range& e) {
35389       {
35390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35391       };
35392     } catch (std::exception& e) {
35393       {
35394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35395       };
35396     } catch (Dali::DaliException e) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35399       };
35400     } catch (...) {
35401       {
35402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35403       };
35404     }
35405   }
35406
35407   jresult = result;
35408   return jresult;
35409 }
35410
35411
35412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35413   void * jresult ;
35414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35415   Dali::Matrix result;
35416
35417   arg1 = (Dali::Actor *)jarg1;
35418   {
35419     try {
35420       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35421     } catch (std::out_of_range& e) {
35422       {
35423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35424       };
35425     } catch (std::exception& e) {
35426       {
35427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35428       };
35429     } catch (Dali::DaliException e) {
35430       {
35431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35432       };
35433     } catch (...) {
35434       {
35435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35436       };
35437     }
35438   }
35439
35440   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35441   return jresult;
35442 }
35443
35444
35445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35447   bool arg2 ;
35448
35449   arg1 = (Dali::Actor *)jarg1;
35450   arg2 = jarg2 ? true : false;
35451   {
35452     try {
35453       (arg1)->SetVisible(arg2);
35454     } catch (std::out_of_range& e) {
35455       {
35456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35457       };
35458     } catch (std::exception& e) {
35459       {
35460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35461       };
35462     } catch (Dali::DaliException e) {
35463       {
35464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35465       };
35466     } catch (...) {
35467       {
35468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35469       };
35470     }
35471   }
35472
35473 }
35474
35475
35476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35477   unsigned int jresult ;
35478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35479   bool result;
35480
35481   arg1 = (Dali::Actor *)jarg1;
35482   {
35483     try {
35484       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35485     } catch (std::out_of_range& e) {
35486       {
35487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35488       };
35489     } catch (std::exception& e) {
35490       {
35491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35492       };
35493     } catch (Dali::DaliException e) {
35494       {
35495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35496       };
35497     } catch (...) {
35498       {
35499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35500       };
35501     }
35502   }
35503
35504   jresult = result;
35505   return jresult;
35506 }
35507
35508
35509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35511   float arg2 ;
35512
35513   arg1 = (Dali::Actor *)jarg1;
35514   arg2 = (float)jarg2;
35515   {
35516     try {
35517       (arg1)->SetOpacity(arg2);
35518     } catch (std::out_of_range& e) {
35519       {
35520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35521       };
35522     } catch (std::exception& e) {
35523       {
35524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35525       };
35526     } catch (Dali::DaliException e) {
35527       {
35528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35529       };
35530     } catch (...) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35533       };
35534     }
35535   }
35536
35537 }
35538
35539
35540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35541   float jresult ;
35542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35543   float result;
35544
35545   arg1 = (Dali::Actor *)jarg1;
35546   {
35547     try {
35548       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35549     } catch (std::out_of_range& e) {
35550       {
35551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35552       };
35553     } catch (std::exception& e) {
35554       {
35555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35556       };
35557     } catch (Dali::DaliException e) {
35558       {
35559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35560       };
35561     } catch (...) {
35562       {
35563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35564       };
35565     }
35566   }
35567
35568   jresult = result;
35569   return jresult;
35570 }
35571
35572
35573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35575   Dali::Vector4 *arg2 = 0 ;
35576
35577   arg1 = (Dali::Actor *)jarg1;
35578   arg2 = (Dali::Vector4 *)jarg2;
35579   if (!arg2) {
35580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35581     return ;
35582   }
35583   {
35584     try {
35585       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35586     } catch (std::out_of_range& e) {
35587       {
35588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35589       };
35590     } catch (std::exception& e) {
35591       {
35592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35593       };
35594     } catch (Dali::DaliException e) {
35595       {
35596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35597       };
35598     } catch (...) {
35599       {
35600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35601       };
35602     }
35603   }
35604
35605 }
35606
35607
35608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35609   void * jresult ;
35610   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35611   Dali::Vector4 result;
35612
35613   arg1 = (Dali::Actor *)jarg1;
35614   {
35615     try {
35616       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35617     } catch (std::out_of_range& e) {
35618       {
35619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35620       };
35621     } catch (std::exception& e) {
35622       {
35623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35624       };
35625     } catch (Dali::DaliException e) {
35626       {
35627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35628       };
35629     } catch (...) {
35630       {
35631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35632       };
35633     }
35634   }
35635
35636   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35637   return jresult;
35638 }
35639
35640
35641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35643   Dali::ColorMode arg2 ;
35644
35645   arg1 = (Dali::Actor *)jarg1;
35646   arg2 = (Dali::ColorMode)jarg2;
35647   {
35648     try {
35649       (arg1)->SetColorMode(arg2);
35650     } catch (std::out_of_range& e) {
35651       {
35652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35653       };
35654     } catch (std::exception& e) {
35655       {
35656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35657       };
35658     } catch (Dali::DaliException e) {
35659       {
35660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35661       };
35662     } catch (...) {
35663       {
35664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35665       };
35666     }
35667   }
35668
35669 }
35670
35671
35672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35673   int jresult ;
35674   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35675   Dali::ColorMode result;
35676
35677   arg1 = (Dali::Actor *)jarg1;
35678   {
35679     try {
35680       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35681     } catch (std::out_of_range& e) {
35682       {
35683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35684       };
35685     } catch (std::exception& e) {
35686       {
35687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35688       };
35689     } catch (Dali::DaliException e) {
35690       {
35691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35692       };
35693     } catch (...) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35696       };
35697     }
35698   }
35699
35700   jresult = (int)result;
35701   return jresult;
35702 }
35703
35704
35705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35706   void * jresult ;
35707   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35708   Dali::Vector4 result;
35709
35710   arg1 = (Dali::Actor *)jarg1;
35711   {
35712     try {
35713       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35714     } catch (std::out_of_range& e) {
35715       {
35716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35717       };
35718     } catch (std::exception& e) {
35719       {
35720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35721       };
35722     } catch (Dali::DaliException e) {
35723       {
35724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35725       };
35726     } catch (...) {
35727       {
35728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35729       };
35730     }
35731   }
35732
35733   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35734   return jresult;
35735 }
35736
35737
35738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35740   Dali::DrawMode::Type arg2 ;
35741
35742   arg1 = (Dali::Actor *)jarg1;
35743   arg2 = (Dali::DrawMode::Type)jarg2;
35744   {
35745     try {
35746       (arg1)->SetDrawMode(arg2);
35747     } catch (std::out_of_range& e) {
35748       {
35749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35750       };
35751     } catch (std::exception& e) {
35752       {
35753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35754       };
35755     } catch (Dali::DaliException e) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35758       };
35759     } catch (...) {
35760       {
35761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35762       };
35763     }
35764   }
35765
35766 }
35767
35768
35769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35770   int jresult ;
35771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35772   Dali::DrawMode::Type result;
35773
35774   arg1 = (Dali::Actor *)jarg1;
35775   {
35776     try {
35777       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35778     } catch (std::out_of_range& e) {
35779       {
35780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35781       };
35782     } catch (std::exception& e) {
35783       {
35784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35785       };
35786     } catch (Dali::DaliException e) {
35787       {
35788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35789       };
35790     } catch (...) {
35791       {
35792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35793       };
35794     }
35795   }
35796
35797   jresult = (int)result;
35798   return jresult;
35799 }
35800
35801
35802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35804   bool arg2 ;
35805
35806   arg1 = (Dali::Actor *)jarg1;
35807   arg2 = jarg2 ? true : false;
35808   {
35809     try {
35810       (arg1)->SetSensitive(arg2);
35811     } catch (std::out_of_range& e) {
35812       {
35813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35814       };
35815     } catch (std::exception& e) {
35816       {
35817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35818       };
35819     } catch (Dali::DaliException e) {
35820       {
35821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35822       };
35823     } catch (...) {
35824       {
35825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35826       };
35827     }
35828   }
35829
35830 }
35831
35832
35833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35834   unsigned int jresult ;
35835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35836   bool result;
35837
35838   arg1 = (Dali::Actor *)jarg1;
35839   {
35840     try {
35841       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35842     } catch (std::out_of_range& e) {
35843       {
35844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35845       };
35846     } catch (std::exception& e) {
35847       {
35848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35849       };
35850     } catch (Dali::DaliException e) {
35851       {
35852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35853       };
35854     } catch (...) {
35855       {
35856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35857       };
35858     }
35859   }
35860
35861   jresult = result;
35862   return jresult;
35863 }
35864
35865
35866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35867   unsigned int jresult ;
35868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35869   float *arg2 = 0 ;
35870   float *arg3 = 0 ;
35871   float arg4 ;
35872   float arg5 ;
35873   bool result;
35874
35875   arg1 = (Dali::Actor *)jarg1;
35876   arg2 = (float *)jarg2;
35877   arg3 = (float *)jarg3;
35878   arg4 = (float)jarg4;
35879   arg5 = (float)jarg5;
35880   {
35881     try {
35882       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35883     } catch (std::out_of_range& e) {
35884       {
35885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35886       };
35887     } catch (std::exception& e) {
35888       {
35889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35890       };
35891     } catch (Dali::DaliException e) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35898       };
35899     }
35900   }
35901
35902   jresult = result;
35903   return jresult;
35904 }
35905
35906
35907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35908   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35909   bool arg2 ;
35910
35911   arg1 = (Dali::Actor *)jarg1;
35912   arg2 = jarg2 ? true : false;
35913   {
35914     try {
35915       (arg1)->SetLeaveRequired(arg2);
35916     } catch (std::out_of_range& e) {
35917       {
35918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35919       };
35920     } catch (std::exception& e) {
35921       {
35922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35923       };
35924     } catch (Dali::DaliException e) {
35925       {
35926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35927       };
35928     } catch (...) {
35929       {
35930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35931       };
35932     }
35933   }
35934
35935 }
35936
35937
35938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35939   unsigned int jresult ;
35940   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35941   bool result;
35942
35943   arg1 = (Dali::Actor *)jarg1;
35944   {
35945     try {
35946       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
35947     } catch (std::out_of_range& e) {
35948       {
35949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35950       };
35951     } catch (std::exception& e) {
35952       {
35953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35954       };
35955     } catch (Dali::DaliException e) {
35956       {
35957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35958       };
35959     } catch (...) {
35960       {
35961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35962       };
35963     }
35964   }
35965
35966   jresult = result;
35967   return jresult;
35968 }
35969
35970
35971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35972   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35973   bool arg2 ;
35974
35975   arg1 = (Dali::Actor *)jarg1;
35976   arg2 = jarg2 ? true : false;
35977   {
35978     try {
35979       (arg1)->SetKeyboardFocusable(arg2);
35980     } catch (std::out_of_range& e) {
35981       {
35982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35983       };
35984     } catch (std::exception& e) {
35985       {
35986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35987       };
35988     } catch (Dali::DaliException e) {
35989       {
35990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35991       };
35992     } catch (...) {
35993       {
35994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35995       };
35996     }
35997   }
35998
35999 }
36000
36001
36002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36003   unsigned int jresult ;
36004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36005   bool result;
36006
36007   arg1 = (Dali::Actor *)jarg1;
36008   {
36009     try {
36010       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36011     } catch (std::out_of_range& e) {
36012       {
36013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36014       };
36015     } catch (std::exception& e) {
36016       {
36017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36018       };
36019     } catch (Dali::DaliException e) {
36020       {
36021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36022       };
36023     } catch (...) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36026       };
36027     }
36028   }
36029
36030   jresult = result;
36031   return jresult;
36032 }
36033
36034
36035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36037   Dali::ResizePolicy::Type arg2 ;
36038   Dali::Dimension::Type arg3 ;
36039
36040   arg1 = (Dali::Actor *)jarg1;
36041   arg2 = (Dali::ResizePolicy::Type)jarg2;
36042   arg3 = (Dali::Dimension::Type)jarg3;
36043   {
36044     try {
36045       (arg1)->SetResizePolicy(arg2,arg3);
36046     } catch (std::out_of_range& e) {
36047       {
36048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36049       };
36050     } catch (std::exception& e) {
36051       {
36052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36053       };
36054     } catch (Dali::DaliException e) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36061       };
36062     }
36063   }
36064
36065 }
36066
36067
36068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36069   int jresult ;
36070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36071   Dali::Dimension::Type arg2 ;
36072   Dali::ResizePolicy::Type result;
36073
36074   arg1 = (Dali::Actor *)jarg1;
36075   arg2 = (Dali::Dimension::Type)jarg2;
36076   {
36077     try {
36078       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36079     } catch (std::out_of_range& e) {
36080       {
36081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36082       };
36083     } catch (std::exception& e) {
36084       {
36085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36086       };
36087     } catch (Dali::DaliException e) {
36088       {
36089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36090       };
36091     } catch (...) {
36092       {
36093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36094       };
36095     }
36096   }
36097
36098   jresult = (int)result;
36099   return jresult;
36100 }
36101
36102
36103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36105   Dali::SizeScalePolicy::Type arg2 ;
36106
36107   arg1 = (Dali::Actor *)jarg1;
36108   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36109   {
36110     try {
36111       (arg1)->SetSizeScalePolicy(arg2);
36112     } catch (std::out_of_range& e) {
36113       {
36114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36115       };
36116     } catch (std::exception& e) {
36117       {
36118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36119       };
36120     } catch (Dali::DaliException e) {
36121       {
36122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36123       };
36124     } catch (...) {
36125       {
36126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36127       };
36128     }
36129   }
36130
36131 }
36132
36133
36134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36135   int jresult ;
36136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36137   Dali::SizeScalePolicy::Type result;
36138
36139   arg1 = (Dali::Actor *)jarg1;
36140   {
36141     try {
36142       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36143     } catch (std::out_of_range& e) {
36144       {
36145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36146       };
36147     } catch (std::exception& e) {
36148       {
36149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36150       };
36151     } catch (Dali::DaliException e) {
36152       {
36153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36154       };
36155     } catch (...) {
36156       {
36157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36158       };
36159     }
36160   }
36161
36162   jresult = (int)result;
36163   return jresult;
36164 }
36165
36166
36167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36169   Dali::Vector3 *arg2 = 0 ;
36170
36171   arg1 = (Dali::Actor *)jarg1;
36172   arg2 = (Dali::Vector3 *)jarg2;
36173   if (!arg2) {
36174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36175     return ;
36176   }
36177   {
36178     try {
36179       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36180     } catch (std::out_of_range& e) {
36181       {
36182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36183       };
36184     } catch (std::exception& e) {
36185       {
36186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36187       };
36188     } catch (Dali::DaliException e) {
36189       {
36190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36191       };
36192     } catch (...) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36195       };
36196     }
36197   }
36198
36199 }
36200
36201
36202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36203   void * jresult ;
36204   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36205   Dali::Vector3 result;
36206
36207   arg1 = (Dali::Actor *)jarg1;
36208   {
36209     try {
36210       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36211     } catch (std::out_of_range& e) {
36212       {
36213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36214       };
36215     } catch (std::exception& e) {
36216       {
36217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (Dali::DaliException e) {
36220       {
36221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36222       };
36223     } catch (...) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36226       };
36227     }
36228   }
36229
36230   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36231   return jresult;
36232 }
36233
36234
36235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36236   float jresult ;
36237   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36238   float arg2 ;
36239   float result;
36240
36241   arg1 = (Dali::Actor *)jarg1;
36242   arg2 = (float)jarg2;
36243   {
36244     try {
36245       result = (float)(arg1)->GetHeightForWidth(arg2);
36246     } catch (std::out_of_range& e) {
36247       {
36248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36249       };
36250     } catch (std::exception& e) {
36251       {
36252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36253       };
36254     } catch (Dali::DaliException e) {
36255       {
36256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36257       };
36258     } catch (...) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36261       };
36262     }
36263   }
36264
36265   jresult = result;
36266   return jresult;
36267 }
36268
36269
36270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36271   float jresult ;
36272   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36273   float arg2 ;
36274   float result;
36275
36276   arg1 = (Dali::Actor *)jarg1;
36277   arg2 = (float)jarg2;
36278   {
36279     try {
36280       result = (float)(arg1)->GetWidthForHeight(arg2);
36281     } catch (std::out_of_range& e) {
36282       {
36283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36284       };
36285     } catch (std::exception& e) {
36286       {
36287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36288       };
36289     } catch (Dali::DaliException e) {
36290       {
36291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36292       };
36293     } catch (...) {
36294       {
36295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36296       };
36297     }
36298   }
36299
36300   jresult = result;
36301   return jresult;
36302 }
36303
36304
36305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36306   float jresult ;
36307   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36308   Dali::Dimension::Type arg2 ;
36309   float result;
36310
36311   arg1 = (Dali::Actor *)jarg1;
36312   arg2 = (Dali::Dimension::Type)jarg2;
36313   {
36314     try {
36315       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36316     } catch (std::out_of_range& e) {
36317       {
36318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36319       };
36320     } catch (std::exception& e) {
36321       {
36322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36323       };
36324     } catch (Dali::DaliException e) {
36325       {
36326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36327       };
36328     } catch (...) {
36329       {
36330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36331       };
36332     }
36333   }
36334
36335   jresult = result;
36336   return jresult;
36337 }
36338
36339
36340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36342   Dali::Padding *arg2 = 0 ;
36343
36344   arg1 = (Dali::Actor *)jarg1;
36345   arg2 = (Dali::Padding *)jarg2;
36346   if (!arg2) {
36347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36348     return ;
36349   }
36350   {
36351     try {
36352       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36353     } catch (std::out_of_range& e) {
36354       {
36355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36356       };
36357     } catch (std::exception& e) {
36358       {
36359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36360       };
36361     } catch (Dali::DaliException e) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36368       };
36369     }
36370   }
36371
36372 }
36373
36374
36375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36376   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36377   Dali::Padding *arg2 = 0 ;
36378
36379   arg1 = (Dali::Actor *)jarg1;
36380   arg2 = (Dali::Padding *)jarg2;
36381   if (!arg2) {
36382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36383     return ;
36384   }
36385   {
36386     try {
36387       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36403       };
36404     }
36405   }
36406
36407 }
36408
36409
36410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36412   Dali::Vector2 *arg2 = 0 ;
36413
36414   arg1 = (Dali::Actor *)jarg1;
36415   arg2 = (Dali::Vector2 *)jarg2;
36416   if (!arg2) {
36417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36418     return ;
36419   }
36420   {
36421     try {
36422       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36430       };
36431     } catch (Dali::DaliException e) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36434       };
36435     } catch (...) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36438       };
36439     }
36440   }
36441
36442 }
36443
36444
36445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36446   void * jresult ;
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   Dali::Vector2 result;
36449
36450   arg1 = (Dali::Actor *)jarg1;
36451   {
36452     try {
36453       result = (arg1)->GetMinimumSize();
36454     } catch (std::out_of_range& e) {
36455       {
36456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36457       };
36458     } catch (std::exception& e) {
36459       {
36460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36461       };
36462     } catch (Dali::DaliException e) {
36463       {
36464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36465       };
36466     } catch (...) {
36467       {
36468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36469       };
36470     }
36471   }
36472
36473   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36474   return jresult;
36475 }
36476
36477
36478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36480   Dali::Vector2 *arg2 = 0 ;
36481
36482   arg1 = (Dali::Actor *)jarg1;
36483   arg2 = (Dali::Vector2 *)jarg2;
36484   if (!arg2) {
36485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36486     return ;
36487   }
36488   {
36489     try {
36490       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36491     } catch (std::out_of_range& e) {
36492       {
36493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36494       };
36495     } catch (std::exception& e) {
36496       {
36497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36498       };
36499     } catch (Dali::DaliException e) {
36500       {
36501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36502       };
36503     } catch (...) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36506       };
36507     }
36508   }
36509
36510 }
36511
36512
36513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36514   void * jresult ;
36515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36516   Dali::Vector2 result;
36517
36518   arg1 = (Dali::Actor *)jarg1;
36519   {
36520     try {
36521       result = (arg1)->GetMaximumSize();
36522     } catch (std::out_of_range& e) {
36523       {
36524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36525       };
36526     } catch (std::exception& e) {
36527       {
36528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (Dali::DaliException e) {
36531       {
36532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36533       };
36534     } catch (...) {
36535       {
36536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36537       };
36538     }
36539   }
36540
36541   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36542   return jresult;
36543 }
36544
36545
36546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36547   int jresult ;
36548   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36549   int result;
36550
36551   arg1 = (Dali::Actor *)jarg1;
36552   {
36553     try {
36554       result = (int)(arg1)->GetHierarchyDepth();
36555     } catch (std::out_of_range& e) {
36556       {
36557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36558       };
36559     } catch (std::exception& e) {
36560       {
36561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36562       };
36563     } catch (Dali::DaliException e) {
36564       {
36565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36566       };
36567     } catch (...) {
36568       {
36569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36570       };
36571     }
36572   }
36573
36574   jresult = result;
36575   return jresult;
36576 }
36577
36578
36579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36580   unsigned int jresult ;
36581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36582   Dali::Renderer *arg2 = 0 ;
36583   unsigned int result;
36584
36585   arg1 = (Dali::Actor *)jarg1;
36586   arg2 = (Dali::Renderer *)jarg2;
36587   if (!arg2) {
36588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36589     return 0;
36590   }
36591   {
36592     try {
36593       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36594     } catch (std::out_of_range& e) {
36595       {
36596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36597       };
36598     } catch (std::exception& e) {
36599       {
36600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36601       };
36602     } catch (Dali::DaliException e) {
36603       {
36604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36605       };
36606     } catch (...) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36609       };
36610     }
36611   }
36612
36613   jresult = result;
36614   return jresult;
36615 }
36616
36617
36618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36619   unsigned int jresult ;
36620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36621   unsigned int result;
36622
36623   arg1 = (Dali::Actor *)jarg1;
36624   {
36625     try {
36626       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36627     } catch (std::out_of_range& e) {
36628       {
36629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36630       };
36631     } catch (std::exception& e) {
36632       {
36633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36634       };
36635     } catch (Dali::DaliException e) {
36636       {
36637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36638       };
36639     } catch (...) {
36640       {
36641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36642       };
36643     }
36644   }
36645
36646   jresult = result;
36647   return jresult;
36648 }
36649
36650
36651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36652   void * jresult ;
36653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36654   unsigned int arg2 ;
36655   Dali::Renderer result;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   arg2 = (unsigned int)jarg2;
36659   {
36660     try {
36661       result = (arg1)->GetRendererAt(arg2);
36662     } catch (std::out_of_range& e) {
36663       {
36664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (std::exception& e) {
36667       {
36668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36669       };
36670     } catch (Dali::DaliException e) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36673       };
36674     } catch (...) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36677       };
36678     }
36679   }
36680
36681   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36682   return jresult;
36683 }
36684
36685
36686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36688   Dali::Renderer *arg2 = 0 ;
36689
36690   arg1 = (Dali::Actor *)jarg1;
36691   arg2 = (Dali::Renderer *)jarg2;
36692   if (!arg2) {
36693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36694     return ;
36695   }
36696   {
36697     try {
36698       (arg1)->RemoveRenderer(*arg2);
36699     } catch (std::out_of_range& e) {
36700       {
36701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36702       };
36703     } catch (std::exception& e) {
36704       {
36705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36706       };
36707     } catch (Dali::DaliException e) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36710       };
36711     } catch (...) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36714       };
36715     }
36716   }
36717
36718 }
36719
36720
36721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36723   unsigned int arg2 ;
36724
36725   arg1 = (Dali::Actor *)jarg1;
36726   arg2 = (unsigned int)jarg2;
36727   {
36728     try {
36729       (arg1)->RemoveRenderer(arg2);
36730     } catch (std::out_of_range& e) {
36731       {
36732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36733       };
36734     } catch (std::exception& e) {
36735       {
36736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36737       };
36738     } catch (Dali::DaliException e) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36741       };
36742     } catch (...) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36745       };
36746     }
36747   }
36748
36749 }
36750
36751
36752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36753   void * jresult ;
36754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36755   Dali::Actor::TouchSignalType *result = 0 ;
36756
36757   arg1 = (Dali::Actor *)jarg1;
36758   {
36759     try {
36760       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36761     } catch (std::out_of_range& e) {
36762       {
36763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36764       };
36765     } catch (std::exception& e) {
36766       {
36767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36768       };
36769     } catch (Dali::DaliException e) {
36770       {
36771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36772       };
36773     } catch (...) {
36774       {
36775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36776       };
36777     }
36778   }
36779
36780   jresult = (void *)result;
36781   return jresult;
36782 }
36783
36784
36785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36786   void * jresult ;
36787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36788   Dali::Actor::TouchDataSignalType *result = 0 ;
36789
36790   arg1 = (Dali::Actor *)jarg1;
36791   {
36792     try {
36793       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36794     } catch (std::out_of_range& e) {
36795       {
36796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36797       };
36798     } catch (std::exception& e) {
36799       {
36800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36801       };
36802     } catch (Dali::DaliException e) {
36803       {
36804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36805       };
36806     } catch (...) {
36807       {
36808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36809       };
36810     }
36811   }
36812
36813   jresult = (void *)result;
36814   return jresult;
36815 }
36816
36817
36818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36819   void * jresult ;
36820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36821   Dali::Actor::HoverSignalType *result = 0 ;
36822
36823   arg1 = (Dali::Actor *)jarg1;
36824   {
36825     try {
36826       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36827     } catch (std::out_of_range& e) {
36828       {
36829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36830       };
36831     } catch (std::exception& e) {
36832       {
36833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (Dali::DaliException e) {
36836       {
36837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36838       };
36839     } catch (...) {
36840       {
36841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36842       };
36843     }
36844   }
36845
36846   jresult = (void *)result;
36847   return jresult;
36848 }
36849
36850
36851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36852   void * jresult ;
36853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36854   Dali::Actor::WheelEventSignalType *result = 0 ;
36855
36856   arg1 = (Dali::Actor *)jarg1;
36857   {
36858     try {
36859       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36860     } catch (std::out_of_range& e) {
36861       {
36862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36863       };
36864     } catch (std::exception& e) {
36865       {
36866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36867       };
36868     } catch (Dali::DaliException e) {
36869       {
36870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36871       };
36872     } catch (...) {
36873       {
36874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36875       };
36876     }
36877   }
36878
36879   jresult = (void *)result;
36880   return jresult;
36881 }
36882
36883
36884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36885   void * jresult ;
36886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36887   Dali::Actor::OnStageSignalType *result = 0 ;
36888
36889   arg1 = (Dali::Actor *)jarg1;
36890   {
36891     try {
36892       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36893     } catch (std::out_of_range& e) {
36894       {
36895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36896       };
36897     } catch (std::exception& e) {
36898       {
36899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36900       };
36901     } catch (Dali::DaliException e) {
36902       {
36903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36904       };
36905     } catch (...) {
36906       {
36907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36908       };
36909     }
36910   }
36911
36912   jresult = (void *)result;
36913   return jresult;
36914 }
36915
36916
36917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36918   void * jresult ;
36919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36920   Dali::Actor::OffStageSignalType *result = 0 ;
36921
36922   arg1 = (Dali::Actor *)jarg1;
36923   {
36924     try {
36925       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36926     } catch (std::out_of_range& e) {
36927       {
36928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36929       };
36930     } catch (std::exception& e) {
36931       {
36932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36933       };
36934     } catch (Dali::DaliException e) {
36935       {
36936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36937       };
36938     } catch (...) {
36939       {
36940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36941       };
36942     }
36943   }
36944
36945   jresult = (void *)result;
36946   return jresult;
36947 }
36948
36949
36950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36951   void * jresult ;
36952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36953   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36954
36955   arg1 = (Dali::Actor *)jarg1;
36956   {
36957     try {
36958       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36959     } catch (std::out_of_range& e) {
36960       {
36961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36962       };
36963     } catch (std::exception& e) {
36964       {
36965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36966       };
36967     } catch (Dali::DaliException e) {
36968       {
36969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36970       };
36971     } catch (...) {
36972       {
36973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36974       };
36975     }
36976   }
36977
36978   jresult = (void *)result;
36979   return jresult;
36980 }
36981
36982
36983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36984   Dali::Actor *arg1 = 0 ;
36985
36986   arg1 = (Dali::Actor *)jarg1;
36987   if (!arg1) {
36988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36989     return ;
36990   }
36991   {
36992     try {
36993       Dali::UnparentAndReset(*arg1);
36994     } catch (std::out_of_range& e) {
36995       {
36996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36997       };
36998     } catch (std::exception& e) {
36999       {
37000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37001       };
37002     } catch (Dali::DaliException e) {
37003       {
37004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37005       };
37006     } catch (...) {
37007       {
37008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37009       };
37010     }
37011   }
37012
37013 }
37014
37015
37016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37017   int jresult ;
37018   int result;
37019
37020   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37021   jresult = (int)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37027   int jresult ;
37028   int result;
37029
37030   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37031   jresult = (int)result;
37032   return jresult;
37033 }
37034
37035
37036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37037   int jresult ;
37038   int result;
37039
37040   result = (int)Dali::Layer::Property::BEHAVIOR;
37041   jresult = (int)result;
37042   return jresult;
37043 }
37044
37045
37046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37047   void * jresult ;
37048   Dali::Layer::Property *result = 0 ;
37049
37050   {
37051     try {
37052       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37053     } catch (std::out_of_range& e) {
37054       {
37055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37056       };
37057     } catch (std::exception& e) {
37058       {
37059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37060       };
37061     } catch (Dali::DaliException e) {
37062       {
37063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37064       };
37065     } catch (...) {
37066       {
37067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37068       };
37069     }
37070   }
37071
37072   jresult = (void *)result;
37073   return jresult;
37074 }
37075
37076
37077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37078   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37079
37080   arg1 = (Dali::Layer::Property *)jarg1;
37081   {
37082     try {
37083       delete arg1;
37084     } catch (std::out_of_range& e) {
37085       {
37086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37087       };
37088     } catch (std::exception& e) {
37089       {
37090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37091       };
37092     } catch (Dali::DaliException e) {
37093       {
37094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37095       };
37096     } catch (...) {
37097       {
37098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37099       };
37100     }
37101   }
37102
37103 }
37104
37105
37106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37107   void * jresult ;
37108   Dali::Layer *result = 0 ;
37109
37110   {
37111     try {
37112       result = (Dali::Layer *)new Dali::Layer();
37113     } catch (std::out_of_range& e) {
37114       {
37115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37116       };
37117     } catch (std::exception& e) {
37118       {
37119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37120       };
37121     } catch (Dali::DaliException e) {
37122       {
37123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37124       };
37125     } catch (...) {
37126       {
37127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37128       };
37129     }
37130   }
37131
37132   jresult = (void *)result;
37133   return jresult;
37134 }
37135
37136
37137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37138   void * jresult ;
37139   Dali::Layer result;
37140
37141   {
37142     try {
37143       result = Dali::Layer::New();
37144     } catch (std::out_of_range& e) {
37145       {
37146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37147       };
37148     } catch (std::exception& e) {
37149       {
37150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37151       };
37152     } catch (Dali::DaliException e) {
37153       {
37154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37155       };
37156     } catch (...) {
37157       {
37158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37159       };
37160     }
37161   }
37162
37163   jresult = new Dali::Layer((const Dali::Layer &)result);
37164   return jresult;
37165 }
37166
37167
37168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37169   void * jresult ;
37170   Dali::BaseHandle arg1 ;
37171   Dali::BaseHandle *argp1 ;
37172   Dali::Layer result;
37173
37174   argp1 = (Dali::BaseHandle *)jarg1;
37175   if (!argp1) {
37176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37177     return 0;
37178   }
37179   arg1 = *argp1;
37180   {
37181     try {
37182       result = Dali::Layer::DownCast(arg1);
37183     } catch (std::out_of_range& e) {
37184       {
37185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37186       };
37187     } catch (std::exception& e) {
37188       {
37189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37190       };
37191     } catch (Dali::DaliException e) {
37192       {
37193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37194       };
37195     } catch (...) {
37196       {
37197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37198       };
37199     }
37200   }
37201
37202   jresult = new Dali::Layer((const Dali::Layer &)result);
37203   return jresult;
37204 }
37205
37206
37207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37208   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37209
37210   arg1 = (Dali::Layer *)jarg1;
37211   {
37212     try {
37213       delete arg1;
37214     } catch (std::out_of_range& e) {
37215       {
37216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37217       };
37218     } catch (std::exception& e) {
37219       {
37220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37221       };
37222     } catch (Dali::DaliException e) {
37223       {
37224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37225       };
37226     } catch (...) {
37227       {
37228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37229       };
37230     }
37231   }
37232
37233 }
37234
37235
37236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37237   void * jresult ;
37238   Dali::Layer *arg1 = 0 ;
37239   Dali::Layer *result = 0 ;
37240
37241   arg1 = (Dali::Layer *)jarg1;
37242   if (!arg1) {
37243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37244     return 0;
37245   }
37246   {
37247     try {
37248       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37249     } catch (std::out_of_range& e) {
37250       {
37251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37252       };
37253     } catch (std::exception& e) {
37254       {
37255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (Dali::DaliException e) {
37258       {
37259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37260       };
37261     } catch (...) {
37262       {
37263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37264       };
37265     }
37266   }
37267
37268   jresult = (void *)result;
37269   return jresult;
37270 }
37271
37272
37273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37274   void * jresult ;
37275   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37276   Dali::Layer *arg2 = 0 ;
37277   Dali::Layer *result = 0 ;
37278
37279   arg1 = (Dali::Layer *)jarg1;
37280   arg2 = (Dali::Layer *)jarg2;
37281   if (!arg2) {
37282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37283     return 0;
37284   }
37285   {
37286     try {
37287       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37288     } catch (std::out_of_range& e) {
37289       {
37290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37291       };
37292     } catch (std::exception& e) {
37293       {
37294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37295       };
37296     } catch (Dali::DaliException e) {
37297       {
37298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37299       };
37300     } catch (...) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37303       };
37304     }
37305   }
37306
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37313   unsigned int jresult ;
37314   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37315   unsigned int result;
37316
37317   arg1 = (Dali::Layer *)jarg1;
37318   {
37319     try {
37320       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37321     } catch (std::out_of_range& e) {
37322       {
37323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37324       };
37325     } catch (std::exception& e) {
37326       {
37327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37328       };
37329     } catch (Dali::DaliException e) {
37330       {
37331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37332       };
37333     } catch (...) {
37334       {
37335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37336       };
37337     }
37338   }
37339
37340   jresult = result;
37341   return jresult;
37342 }
37343
37344
37345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37346   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37347
37348   arg1 = (Dali::Layer *)jarg1;
37349   {
37350     try {
37351       (arg1)->Raise();
37352     } catch (std::out_of_range& e) {
37353       {
37354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37355       };
37356     } catch (std::exception& e) {
37357       {
37358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37359       };
37360     } catch (Dali::DaliException e) {
37361       {
37362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37363       };
37364     } catch (...) {
37365       {
37366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37367       };
37368     }
37369   }
37370
37371 }
37372
37373
37374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37375   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37376
37377   arg1 = (Dali::Layer *)jarg1;
37378   {
37379     try {
37380       (arg1)->Lower();
37381     } catch (std::out_of_range& e) {
37382       {
37383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37384       };
37385     } catch (std::exception& e) {
37386       {
37387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37388       };
37389     } catch (Dali::DaliException e) {
37390       {
37391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37392       };
37393     } catch (...) {
37394       {
37395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37396       };
37397     }
37398   }
37399
37400 }
37401
37402
37403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37404   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37405   Dali::Layer arg2 ;
37406   Dali::Layer *argp2 ;
37407
37408   arg1 = (Dali::Layer *)jarg1;
37409   argp2 = (Dali::Layer *)jarg2;
37410   if (!argp2) {
37411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37412     return ;
37413   }
37414   arg2 = *argp2;
37415   {
37416     try {
37417       (arg1)->RaiseAbove(arg2);
37418     } catch (std::out_of_range& e) {
37419       {
37420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37421       };
37422     } catch (std::exception& e) {
37423       {
37424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37425       };
37426     } catch (Dali::DaliException e) {
37427       {
37428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37429       };
37430     } catch (...) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37433       };
37434     }
37435   }
37436
37437 }
37438
37439
37440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37441   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37442   Dali::Layer arg2 ;
37443   Dali::Layer *argp2 ;
37444
37445   arg1 = (Dali::Layer *)jarg1;
37446   argp2 = (Dali::Layer *)jarg2;
37447   if (!argp2) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37449     return ;
37450   }
37451   arg2 = *argp2;
37452   {
37453     try {
37454       (arg1)->LowerBelow(arg2);
37455     } catch (std::out_of_range& e) {
37456       {
37457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37458       };
37459     } catch (std::exception& e) {
37460       {
37461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37462       };
37463     } catch (Dali::DaliException e) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37466       };
37467     } catch (...) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37470       };
37471     }
37472   }
37473
37474 }
37475
37476
37477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37478   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37479
37480   arg1 = (Dali::Layer *)jarg1;
37481   {
37482     try {
37483       (arg1)->RaiseToTop();
37484     } catch (std::out_of_range& e) {
37485       {
37486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37487       };
37488     } catch (std::exception& e) {
37489       {
37490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37491       };
37492     } catch (Dali::DaliException e) {
37493       {
37494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37495       };
37496     } catch (...) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37499       };
37500     }
37501   }
37502
37503 }
37504
37505
37506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37507   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37508
37509   arg1 = (Dali::Layer *)jarg1;
37510   {
37511     try {
37512       (arg1)->LowerToBottom();
37513     } catch (std::out_of_range& e) {
37514       {
37515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37516       };
37517     } catch (std::exception& e) {
37518       {
37519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37520       };
37521     } catch (Dali::DaliException e) {
37522       {
37523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37524       };
37525     } catch (...) {
37526       {
37527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37528       };
37529     }
37530   }
37531
37532 }
37533
37534
37535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37536   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37537   Dali::Layer arg2 ;
37538   Dali::Layer *argp2 ;
37539
37540   arg1 = (Dali::Layer *)jarg1;
37541   argp2 = (Dali::Layer *)jarg2;
37542   if (!argp2) {
37543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37544     return ;
37545   }
37546   arg2 = *argp2;
37547   {
37548     try {
37549       (arg1)->MoveAbove(arg2);
37550     } catch (std::out_of_range& e) {
37551       {
37552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37553       };
37554     } catch (std::exception& e) {
37555       {
37556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37557       };
37558     } catch (Dali::DaliException e) {
37559       {
37560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37561       };
37562     } catch (...) {
37563       {
37564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37565       };
37566     }
37567   }
37568
37569 }
37570
37571
37572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37573   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37574   Dali::Layer arg2 ;
37575   Dali::Layer *argp2 ;
37576
37577   arg1 = (Dali::Layer *)jarg1;
37578   argp2 = (Dali::Layer *)jarg2;
37579   if (!argp2) {
37580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37581     return ;
37582   }
37583   arg2 = *argp2;
37584   {
37585     try {
37586       (arg1)->MoveBelow(arg2);
37587     } catch (std::out_of_range& e) {
37588       {
37589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37590       };
37591     } catch (std::exception& e) {
37592       {
37593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37594       };
37595     } catch (Dali::DaliException e) {
37596       {
37597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37598       };
37599     } catch (...) {
37600       {
37601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37602       };
37603     }
37604   }
37605
37606 }
37607
37608
37609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37610   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37611   Dali::Layer::Behavior arg2 ;
37612
37613   arg1 = (Dali::Layer *)jarg1;
37614   arg2 = (Dali::Layer::Behavior)jarg2;
37615   {
37616     try {
37617       (arg1)->SetBehavior(arg2);
37618     } catch (std::out_of_range& e) {
37619       {
37620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37621       };
37622     } catch (std::exception& e) {
37623       {
37624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37625       };
37626     } catch (Dali::DaliException e) {
37627       {
37628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37629       };
37630     } catch (...) {
37631       {
37632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37633       };
37634     }
37635   }
37636
37637 }
37638
37639
37640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37641   int jresult ;
37642   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37643   Dali::Layer::Behavior result;
37644
37645   arg1 = (Dali::Layer *)jarg1;
37646   {
37647     try {
37648       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37649     } catch (std::out_of_range& e) {
37650       {
37651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37652       };
37653     } catch (std::exception& e) {
37654       {
37655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37656       };
37657     } catch (Dali::DaliException e) {
37658       {
37659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37660       };
37661     } catch (...) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37664       };
37665     }
37666   }
37667
37668   jresult = (int)result;
37669   return jresult;
37670 }
37671
37672
37673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37674   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37675   bool arg2 ;
37676
37677   arg1 = (Dali::Layer *)jarg1;
37678   arg2 = jarg2 ? true : false;
37679   {
37680     try {
37681       (arg1)->SetClipping(arg2);
37682     } catch (std::out_of_range& e) {
37683       {
37684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37685       };
37686     } catch (std::exception& e) {
37687       {
37688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37689       };
37690     } catch (Dali::DaliException e) {
37691       {
37692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37693       };
37694     } catch (...) {
37695       {
37696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37697       };
37698     }
37699   }
37700
37701 }
37702
37703
37704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37705   unsigned int jresult ;
37706   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37707   bool result;
37708
37709   arg1 = (Dali::Layer *)jarg1;
37710   {
37711     try {
37712       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37713     } catch (std::out_of_range& e) {
37714       {
37715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37716       };
37717     } catch (std::exception& e) {
37718       {
37719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37720       };
37721     } catch (Dali::DaliException e) {
37722       {
37723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37724       };
37725     } catch (...) {
37726       {
37727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37728       };
37729     }
37730   }
37731
37732   jresult = result;
37733   return jresult;
37734 }
37735
37736
37737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37738   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37739   int arg2 ;
37740   int arg3 ;
37741   int arg4 ;
37742   int arg5 ;
37743
37744   arg1 = (Dali::Layer *)jarg1;
37745   arg2 = (int)jarg2;
37746   arg3 = (int)jarg3;
37747   arg4 = (int)jarg4;
37748   arg5 = (int)jarg5;
37749   {
37750     try {
37751       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37752     } catch (std::out_of_range& e) {
37753       {
37754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37755       };
37756     } catch (std::exception& e) {
37757       {
37758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37759       };
37760     } catch (Dali::DaliException e) {
37761       {
37762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37763       };
37764     } catch (...) {
37765       {
37766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37767       };
37768     }
37769   }
37770
37771 }
37772
37773
37774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37775   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37776   Dali::ClippingBox arg2 ;
37777   Dali::ClippingBox *argp2 ;
37778
37779   arg1 = (Dali::Layer *)jarg1;
37780   argp2 = (Dali::ClippingBox *)jarg2;
37781   if (!argp2) {
37782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37783     return ;
37784   }
37785   arg2 = *argp2;
37786   {
37787     try {
37788       (arg1)->SetClippingBox(arg2);
37789     } catch (std::out_of_range& e) {
37790       {
37791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (std::exception& e) {
37794       {
37795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (Dali::DaliException e) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37804       };
37805     }
37806   }
37807
37808 }
37809
37810
37811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37812   void * jresult ;
37813   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37814   Dali::ClippingBox result;
37815
37816   arg1 = (Dali::Layer *)jarg1;
37817   {
37818     try {
37819       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37820     } catch (std::out_of_range& e) {
37821       {
37822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37823       };
37824     } catch (std::exception& e) {
37825       {
37826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37827       };
37828     } catch (Dali::DaliException e) {
37829       {
37830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37831       };
37832     } catch (...) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37835       };
37836     }
37837   }
37838
37839   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37840   return jresult;
37841 }
37842
37843
37844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37845   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37846   bool arg2 ;
37847
37848   arg1 = (Dali::Layer *)jarg1;
37849   arg2 = jarg2 ? true : false;
37850   {
37851     try {
37852       (arg1)->SetDepthTestDisabled(arg2);
37853     } catch (std::out_of_range& e) {
37854       {
37855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37856       };
37857     } catch (std::exception& e) {
37858       {
37859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37860       };
37861     } catch (Dali::DaliException e) {
37862       {
37863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37864       };
37865     } catch (...) {
37866       {
37867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37868       };
37869     }
37870   }
37871
37872 }
37873
37874
37875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37876   unsigned int jresult ;
37877   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37878   bool result;
37879
37880   arg1 = (Dali::Layer *)jarg1;
37881   {
37882     try {
37883       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37884     } catch (std::out_of_range& e) {
37885       {
37886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37887       };
37888     } catch (std::exception& e) {
37889       {
37890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37891       };
37892     } catch (Dali::DaliException e) {
37893       {
37894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37895       };
37896     } catch (...) {
37897       {
37898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37899       };
37900     }
37901   }
37902
37903   jresult = result;
37904   return jresult;
37905 }
37906
37907
37908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37909   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37910   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37911
37912   arg1 = (Dali::Layer *)jarg1;
37913   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37914   {
37915     try {
37916       (arg1)->SetSortFunction(arg2);
37917     } catch (std::out_of_range& e) {
37918       {
37919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37920       };
37921     } catch (std::exception& e) {
37922       {
37923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37924       };
37925     } catch (Dali::DaliException e) {
37926       {
37927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37928       };
37929     } catch (...) {
37930       {
37931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37932       };
37933     }
37934   }
37935
37936 }
37937
37938
37939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37940   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37941   bool arg2 ;
37942
37943   arg1 = (Dali::Layer *)jarg1;
37944   arg2 = jarg2 ? true : false;
37945   {
37946     try {
37947       (arg1)->SetTouchConsumed(arg2);
37948     } catch (std::out_of_range& e) {
37949       {
37950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37951       };
37952     } catch (std::exception& e) {
37953       {
37954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37955       };
37956     } catch (Dali::DaliException e) {
37957       {
37958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37959       };
37960     } catch (...) {
37961       {
37962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37963       };
37964     }
37965   }
37966
37967 }
37968
37969
37970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37971   unsigned int jresult ;
37972   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37973   bool result;
37974
37975   arg1 = (Dali::Layer *)jarg1;
37976   {
37977     try {
37978       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
37979     } catch (std::out_of_range& e) {
37980       {
37981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37982       };
37983     } catch (std::exception& e) {
37984       {
37985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37986       };
37987     } catch (Dali::DaliException e) {
37988       {
37989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37990       };
37991     } catch (...) {
37992       {
37993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37994       };
37995     }
37996   }
37997
37998   jresult = result;
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38004   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38005   bool arg2 ;
38006
38007   arg1 = (Dali::Layer *)jarg1;
38008   arg2 = jarg2 ? true : false;
38009   {
38010     try {
38011       (arg1)->SetHoverConsumed(arg2);
38012     } catch (std::out_of_range& e) {
38013       {
38014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38015       };
38016     } catch (std::exception& e) {
38017       {
38018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38019       };
38020     } catch (Dali::DaliException e) {
38021       {
38022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38023       };
38024     } catch (...) {
38025       {
38026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38027       };
38028     }
38029   }
38030
38031 }
38032
38033
38034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38035   unsigned int jresult ;
38036   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38037   bool result;
38038
38039   arg1 = (Dali::Layer *)jarg1;
38040   {
38041     try {
38042       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38043     } catch (std::out_of_range& e) {
38044       {
38045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38046       };
38047     } catch (std::exception& e) {
38048       {
38049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38050       };
38051     } catch (Dali::DaliException e) {
38052       {
38053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38054       };
38055     } catch (...) {
38056       {
38057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38058       };
38059     }
38060   }
38061
38062   jresult = result;
38063   return jresult;
38064 }
38065
38066
38067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38068   void * jresult ;
38069   Dali::Vector4 *result = 0 ;
38070
38071   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38072   jresult = (void *)result;
38073   return jresult;
38074 }
38075
38076
38077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38078   void * jresult ;
38079   Dali::Vector4 *result = 0 ;
38080
38081   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38082   jresult = (void *)result;
38083   return jresult;
38084 }
38085
38086
38087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38088   void * jresult ;
38089   Dali::Stage *result = 0 ;
38090
38091   {
38092     try {
38093       result = (Dali::Stage *)new Dali::Stage();
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (Dali::DaliException e) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38105       };
38106     } catch (...) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38109       };
38110     }
38111   }
38112
38113   jresult = (void *)result;
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38119   void * jresult ;
38120   Dali::Stage result;
38121
38122   {
38123     try {
38124       result = Dali::Stage::GetCurrent();
38125     } catch (std::out_of_range& e) {
38126       {
38127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38128       };
38129     } catch (std::exception& e) {
38130       {
38131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38132       };
38133     } catch (Dali::DaliException e) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38136       };
38137     } catch (...) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38140       };
38141     }
38142   }
38143
38144   jresult = new Dali::Stage((const Dali::Stage &)result);
38145   return jresult;
38146 }
38147
38148
38149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38150   unsigned int jresult ;
38151   bool result;
38152
38153   {
38154     try {
38155       result = (bool)Dali::Stage::IsInstalled();
38156     } catch (std::out_of_range& e) {
38157       {
38158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38159       };
38160     } catch (std::exception& e) {
38161       {
38162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (Dali::DaliException e) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38167       };
38168     } catch (...) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38171       };
38172     }
38173   }
38174
38175   jresult = result;
38176   return jresult;
38177 }
38178
38179
38180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38181   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38182
38183   arg1 = (Dali::Stage *)jarg1;
38184   {
38185     try {
38186       delete arg1;
38187     } catch (std::out_of_range& e) {
38188       {
38189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38190       };
38191     } catch (std::exception& e) {
38192       {
38193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38194       };
38195     } catch (Dali::DaliException e) {
38196       {
38197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38198       };
38199     } catch (...) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38202       };
38203     }
38204   }
38205
38206 }
38207
38208
38209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38210   void * jresult ;
38211   Dali::Stage *arg1 = 0 ;
38212   Dali::Stage *result = 0 ;
38213
38214   arg1 = (Dali::Stage *)jarg1;
38215   if (!arg1) {
38216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38217     return 0;
38218   }
38219   {
38220     try {
38221       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38222     } catch (std::out_of_range& e) {
38223       {
38224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38225       };
38226     } catch (std::exception& e) {
38227       {
38228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38229       };
38230     } catch (Dali::DaliException e) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38233       };
38234     } catch (...) {
38235       {
38236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38237       };
38238     }
38239   }
38240
38241   jresult = (void *)result;
38242   return jresult;
38243 }
38244
38245
38246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38247   void * jresult ;
38248   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38249   Dali::Stage *arg2 = 0 ;
38250   Dali::Stage *result = 0 ;
38251
38252   arg1 = (Dali::Stage *)jarg1;
38253   arg2 = (Dali::Stage *)jarg2;
38254   if (!arg2) {
38255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38256     return 0;
38257   }
38258   {
38259     try {
38260       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38261     } catch (std::out_of_range& e) {
38262       {
38263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38264       };
38265     } catch (std::exception& e) {
38266       {
38267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38268       };
38269     } catch (Dali::DaliException e) {
38270       {
38271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38272       };
38273     } catch (...) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38276       };
38277     }
38278   }
38279
38280   jresult = (void *)result;
38281   return jresult;
38282 }
38283
38284
38285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38286   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38287   Dali::Actor *arg2 = 0 ;
38288
38289   arg1 = (Dali::Stage *)jarg1;
38290   arg2 = (Dali::Actor *)jarg2;
38291   if (!arg2) {
38292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38293     return ;
38294   }
38295   {
38296     try {
38297       (arg1)->Add(*arg2);
38298     } catch (std::out_of_range& e) {
38299       {
38300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38301       };
38302     } catch (std::exception& e) {
38303       {
38304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38305       };
38306     } catch (Dali::DaliException e) {
38307       {
38308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38309       };
38310     } catch (...) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38313       };
38314     }
38315   }
38316
38317 }
38318
38319
38320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38321   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38322   Dali::Actor *arg2 = 0 ;
38323
38324   arg1 = (Dali::Stage *)jarg1;
38325   arg2 = (Dali::Actor *)jarg2;
38326   if (!arg2) {
38327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38328     return ;
38329   }
38330   {
38331     try {
38332       (arg1)->Remove(*arg2);
38333     } catch (std::out_of_range& e) {
38334       {
38335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38336       };
38337     } catch (std::exception& e) {
38338       {
38339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38340       };
38341     } catch (Dali::DaliException e) {
38342       {
38343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38344       };
38345     } catch (...) {
38346       {
38347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38348       };
38349     }
38350   }
38351
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38356   void * jresult ;
38357   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38358   Dali::Vector2 result;
38359
38360   arg1 = (Dali::Stage *)jarg1;
38361   {
38362     try {
38363       result = ((Dali::Stage const *)arg1)->GetSize();
38364     } catch (std::out_of_range& e) {
38365       {
38366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38367       };
38368     } catch (std::exception& e) {
38369       {
38370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (Dali::DaliException e) {
38373       {
38374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38375       };
38376     } catch (...) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38379       };
38380     }
38381   }
38382
38383   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38384   return jresult;
38385 }
38386
38387
38388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38389   void * jresult ;
38390   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38391   Dali::RenderTaskList result;
38392
38393   arg1 = (Dali::Stage *)jarg1;
38394   {
38395     try {
38396       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38397     } catch (std::out_of_range& e) {
38398       {
38399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38400       };
38401     } catch (std::exception& e) {
38402       {
38403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38404       };
38405     } catch (Dali::DaliException e) {
38406       {
38407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38408       };
38409     } catch (...) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38412       };
38413     }
38414   }
38415
38416   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38417   return jresult;
38418 }
38419
38420
38421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38422   unsigned int jresult ;
38423   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38424   unsigned int result;
38425
38426   arg1 = (Dali::Stage *)jarg1;
38427   {
38428     try {
38429       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38430     } catch (std::out_of_range& e) {
38431       {
38432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38433       };
38434     } catch (std::exception& e) {
38435       {
38436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (Dali::DaliException e) {
38439       {
38440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38441       };
38442     } catch (...) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38445       };
38446     }
38447   }
38448
38449   jresult = result;
38450   return jresult;
38451 }
38452
38453
38454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38455   void * jresult ;
38456   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38457   unsigned int arg2 ;
38458   Dali::Layer result;
38459
38460   arg1 = (Dali::Stage *)jarg1;
38461   arg2 = (unsigned int)jarg2;
38462   {
38463     try {
38464       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38465     } catch (std::out_of_range& e) {
38466       {
38467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38468       };
38469     } catch (std::exception& e) {
38470       {
38471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38472       };
38473     } catch (Dali::DaliException e) {
38474       {
38475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38476       };
38477     } catch (...) {
38478       {
38479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38480       };
38481     }
38482   }
38483
38484   jresult = new Dali::Layer((const Dali::Layer &)result);
38485   return jresult;
38486 }
38487
38488
38489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38490   void * jresult ;
38491   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38492   Dali::Layer result;
38493
38494   arg1 = (Dali::Stage *)jarg1;
38495   {
38496     try {
38497       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38498     } catch (std::out_of_range& e) {
38499       {
38500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38501       };
38502     } catch (std::exception& e) {
38503       {
38504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38505       };
38506     } catch (Dali::DaliException e) {
38507       {
38508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38509       };
38510     } catch (...) {
38511       {
38512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38513       };
38514     }
38515   }
38516
38517   jresult = new Dali::Layer((const Dali::Layer &)result);
38518   return jresult;
38519 }
38520
38521
38522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38523   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38524   Dali::Vector4 arg2 ;
38525   Dali::Vector4 *argp2 ;
38526
38527   arg1 = (Dali::Stage *)jarg1;
38528   argp2 = (Dali::Vector4 *)jarg2;
38529   if (!argp2) {
38530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38531     return ;
38532   }
38533   arg2 = *argp2;
38534   {
38535     try {
38536       (arg1)->SetBackgroundColor(arg2);
38537     } catch (std::out_of_range& e) {
38538       {
38539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38540       };
38541     } catch (std::exception& e) {
38542       {
38543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38544       };
38545     } catch (Dali::DaliException e) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38552       };
38553     }
38554   }
38555
38556 }
38557
38558
38559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38560   void * jresult ;
38561   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38562   Dali::Vector4 result;
38563
38564   arg1 = (Dali::Stage *)jarg1;
38565   {
38566     try {
38567       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38568     } catch (std::out_of_range& e) {
38569       {
38570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38571       };
38572     } catch (std::exception& e) {
38573       {
38574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (Dali::DaliException e) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38579       };
38580     } catch (...) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38583       };
38584     }
38585   }
38586
38587   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38588   return jresult;
38589 }
38590
38591
38592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38593   void * jresult ;
38594   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38595   Dali::Vector2 result;
38596
38597   arg1 = (Dali::Stage *)jarg1;
38598   {
38599     try {
38600       result = ((Dali::Stage const *)arg1)->GetDpi();
38601     } catch (std::out_of_range& e) {
38602       {
38603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38604       };
38605     } catch (std::exception& e) {
38606       {
38607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38608       };
38609     } catch (Dali::DaliException e) {
38610       {
38611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38612       };
38613     } catch (...) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38616       };
38617     }
38618   }
38619
38620   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38621   return jresult;
38622 }
38623
38624
38625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38626   void * jresult ;
38627   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38628   Dali::ObjectRegistry result;
38629
38630   arg1 = (Dali::Stage *)jarg1;
38631   {
38632     try {
38633       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38634     } catch (std::out_of_range& e) {
38635       {
38636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38637       };
38638     } catch (std::exception& e) {
38639       {
38640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38641       };
38642     } catch (Dali::DaliException e) {
38643       {
38644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38645       };
38646     } catch (...) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38649       };
38650     }
38651   }
38652
38653   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38654   return jresult;
38655 }
38656
38657
38658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38659   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38660   float arg2 ;
38661
38662   arg1 = (Dali::Stage *)jarg1;
38663   arg2 = (float)jarg2;
38664   {
38665     try {
38666       (arg1)->KeepRendering(arg2);
38667     } catch (std::out_of_range& e) {
38668       {
38669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38670       };
38671     } catch (std::exception& e) {
38672       {
38673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38674       };
38675     } catch (Dali::DaliException e) {
38676       {
38677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38678       };
38679     } catch (...) {
38680       {
38681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38682       };
38683     }
38684   }
38685
38686 }
38687
38688
38689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38690   void * jresult ;
38691   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38692   Dali::Stage::KeyEventSignalType *result = 0 ;
38693
38694   arg1 = (Dali::Stage *)jarg1;
38695   {
38696     try {
38697       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38698     } catch (std::out_of_range& e) {
38699       {
38700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38701       };
38702     } catch (std::exception& e) {
38703       {
38704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38705       };
38706     } catch (Dali::DaliException e) {
38707       {
38708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38709       };
38710     } catch (...) {
38711       {
38712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38713       };
38714     }
38715   }
38716
38717   jresult = (void *)result;
38718   return jresult;
38719 }
38720
38721
38722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38723   void * jresult ;
38724   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38725   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38726
38727   arg1 = (Dali::Stage *)jarg1;
38728   {
38729     try {
38730       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38731     } catch (std::out_of_range& e) {
38732       {
38733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38734       };
38735     } catch (std::exception& e) {
38736       {
38737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38738       };
38739     } catch (Dali::DaliException e) {
38740       {
38741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38742       };
38743     } catch (...) {
38744       {
38745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38746       };
38747     }
38748   }
38749
38750   jresult = (void *)result;
38751   return jresult;
38752 }
38753
38754
38755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38756   void * jresult ;
38757   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38758   Dali::Stage::TouchSignalType *result = 0 ;
38759
38760   arg1 = (Dali::Stage *)jarg1;
38761   {
38762     try {
38763       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38764     } catch (std::out_of_range& e) {
38765       {
38766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38767       };
38768     } catch (std::exception& e) {
38769       {
38770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38771       };
38772     } catch (Dali::DaliException e) {
38773       {
38774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38775       };
38776     } catch (...) {
38777       {
38778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38779       };
38780     }
38781   }
38782
38783   jresult = (void *)result;
38784   return jresult;
38785 }
38786
38787
38788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38789   void * jresult ;
38790   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38791   Dali::Stage::WheelEventSignalType *result = 0 ;
38792
38793   arg1 = (Dali::Stage *)jarg1;
38794   {
38795     try {
38796       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38797     } catch (std::out_of_range& e) {
38798       {
38799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (std::exception& e) {
38802       {
38803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38804       };
38805     } catch (Dali::DaliException e) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38808       };
38809     } catch (...) {
38810       {
38811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38812       };
38813     }
38814   }
38815
38816   jresult = (void *)result;
38817   return jresult;
38818 }
38819
38820
38821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38822   void * jresult ;
38823   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38824   Dali::Stage::ContextStatusSignal *result = 0 ;
38825
38826   arg1 = (Dali::Stage *)jarg1;
38827   {
38828     try {
38829       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38830     } catch (std::out_of_range& e) {
38831       {
38832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38833       };
38834     } catch (std::exception& e) {
38835       {
38836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38837       };
38838     } catch (Dali::DaliException e) {
38839       {
38840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38841       };
38842     } catch (...) {
38843       {
38844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38845       };
38846     }
38847   }
38848
38849   jresult = (void *)result;
38850   return jresult;
38851 }
38852
38853
38854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38855   void * jresult ;
38856   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38857   Dali::Stage::ContextStatusSignal *result = 0 ;
38858
38859   arg1 = (Dali::Stage *)jarg1;
38860   {
38861     try {
38862       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38863     } catch (std::out_of_range& e) {
38864       {
38865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38866       };
38867     } catch (std::exception& e) {
38868       {
38869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38870       };
38871     } catch (Dali::DaliException e) {
38872       {
38873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38874       };
38875     } catch (...) {
38876       {
38877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38878       };
38879     }
38880   }
38881
38882   jresult = (void *)result;
38883   return jresult;
38884 }
38885
38886
38887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38888   void * jresult ;
38889   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38890   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38891
38892   arg1 = (Dali::Stage *)jarg1;
38893   {
38894     try {
38895       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38896     } catch (std::out_of_range& e) {
38897       {
38898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38899       };
38900     } catch (std::exception& e) {
38901       {
38902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38903       };
38904     } catch (Dali::DaliException e) {
38905       {
38906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38907       };
38908     } catch (...) {
38909       {
38910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38911       };
38912     }
38913   }
38914
38915   jresult = (void *)result;
38916   return jresult;
38917 }
38918
38919
38920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38921   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38922
38923   arg1 = (Dali::RelayoutContainer *)jarg1;
38924   {
38925     try {
38926       delete arg1;
38927     } catch (std::out_of_range& e) {
38928       {
38929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38930       };
38931     } catch (std::exception& e) {
38932       {
38933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38934       };
38935     } catch (Dali::DaliException e) {
38936       {
38937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38938       };
38939     } catch (...) {
38940       {
38941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38942       };
38943     }
38944   }
38945
38946 }
38947
38948
38949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38950   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38951   Dali::Actor *arg2 = 0 ;
38952   Dali::Vector2 *arg3 = 0 ;
38953
38954   arg1 = (Dali::RelayoutContainer *)jarg1;
38955   arg2 = (Dali::Actor *)jarg2;
38956   if (!arg2) {
38957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38958     return ;
38959   }
38960   arg3 = (Dali::Vector2 *)jarg3;
38961   if (!arg3) {
38962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38963     return ;
38964   }
38965   {
38966     try {
38967       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38968     } catch (std::out_of_range& e) {
38969       {
38970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38971       };
38972     } catch (std::exception& e) {
38973       {
38974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38975       };
38976     } catch (Dali::DaliException e) {
38977       {
38978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38979       };
38980     } catch (...) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38983       };
38984     }
38985   }
38986
38987 }
38988
38989
38990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38991   void * jresult ;
38992   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38993   Dali::CustomActor result;
38994
38995   arg1 = (Dali::CustomActorImpl *)jarg1;
38996   {
38997     try {
38998       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38999     } catch (std::out_of_range& e) {
39000       {
39001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39002       };
39003     } catch (std::exception& e) {
39004       {
39005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39006       };
39007     } catch (Dali::DaliException e) {
39008       {
39009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39010       };
39011     } catch (...) {
39012       {
39013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39014       };
39015     }
39016   }
39017
39018   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39019   return jresult;
39020 }
39021
39022
39023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39024   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39025   int arg2 ;
39026
39027   arg1 = (Dali::CustomActorImpl *)jarg1;
39028   arg2 = (int)jarg2;
39029   {
39030     try {
39031       (arg1)->OnStageConnection(arg2);
39032     } catch (std::out_of_range& e) {
39033       {
39034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39035       };
39036     } catch (std::exception& e) {
39037       {
39038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39039       };
39040     } catch (Dali::DaliException e) {
39041       {
39042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39043       };
39044     } catch (...) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39047       };
39048     }
39049   }
39050
39051 }
39052
39053
39054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39055   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39056
39057   arg1 = (Dali::CustomActorImpl *)jarg1;
39058   {
39059     try {
39060       (arg1)->OnStageDisconnection();
39061     } catch (std::out_of_range& e) {
39062       {
39063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39064       };
39065     } catch (std::exception& e) {
39066       {
39067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39068       };
39069     } catch (Dali::DaliException e) {
39070       {
39071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39072       };
39073     } catch (...) {
39074       {
39075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39076       };
39077     }
39078   }
39079
39080 }
39081
39082
39083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39084   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39085   Dali::Actor *arg2 = 0 ;
39086
39087   arg1 = (Dali::CustomActorImpl *)jarg1;
39088   arg2 = (Dali::Actor *)jarg2;
39089   if (!arg2) {
39090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39091     return ;
39092   }
39093   {
39094     try {
39095       (arg1)->OnChildAdd(*arg2);
39096     } catch (std::out_of_range& e) {
39097       {
39098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39099       };
39100     } catch (std::exception& e) {
39101       {
39102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39103       };
39104     } catch (Dali::DaliException e) {
39105       {
39106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39107       };
39108     } catch (...) {
39109       {
39110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39111       };
39112     }
39113   }
39114
39115 }
39116
39117
39118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39119   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39120   Dali::Actor *arg2 = 0 ;
39121
39122   arg1 = (Dali::CustomActorImpl *)jarg1;
39123   arg2 = (Dali::Actor *)jarg2;
39124   if (!arg2) {
39125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39126     return ;
39127   }
39128   {
39129     try {
39130       (arg1)->OnChildRemove(*arg2);
39131     } catch (std::out_of_range& e) {
39132       {
39133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39134       };
39135     } catch (std::exception& e) {
39136       {
39137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39138       };
39139     } catch (Dali::DaliException e) {
39140       {
39141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39142       };
39143     } catch (...) {
39144       {
39145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39146       };
39147     }
39148   }
39149
39150 }
39151
39152
39153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39154   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39155   Dali::Property::Index arg2 ;
39156   Dali::Property::Value arg3 ;
39157   Dali::Property::Value *argp3 ;
39158
39159   arg1 = (Dali::CustomActorImpl *)jarg1;
39160   arg2 = (Dali::Property::Index)jarg2;
39161   argp3 = (Dali::Property::Value *)jarg3;
39162   if (!argp3) {
39163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39164     return ;
39165   }
39166   arg3 = *argp3;
39167   {
39168     try {
39169       (arg1)->OnPropertySet(arg2,arg3);
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39177       };
39178     } catch (Dali::DaliException e) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39185       };
39186     }
39187   }
39188
39189 }
39190
39191
39192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39193   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39194   Dali::Vector3 *arg2 = 0 ;
39195
39196   arg1 = (Dali::CustomActorImpl *)jarg1;
39197   arg2 = (Dali::Vector3 *)jarg2;
39198   if (!arg2) {
39199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39200     return ;
39201   }
39202   {
39203     try {
39204       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39205     } catch (std::out_of_range& e) {
39206       {
39207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39208       };
39209     } catch (std::exception& e) {
39210       {
39211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39212       };
39213     } catch (Dali::DaliException e) {
39214       {
39215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39216       };
39217     } catch (...) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39220       };
39221     }
39222   }
39223
39224 }
39225
39226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39227   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39228   Dali::Animation *arg2 = 0 ;
39229   Dali::Vector3 *arg3 = 0 ;
39230
39231   arg1 = (Dali::CustomActorImpl *)jarg1;
39232   arg2 = (Dali::Animation *)jarg2;
39233   if (!arg2) {
39234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39235     return ;
39236   }
39237   arg3 = (Dali::Vector3 *)jarg3;
39238   if (!arg3) {
39239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39240     return ;
39241   }
39242   {
39243     try {
39244       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39245     } catch (std::out_of_range& e) {
39246       {
39247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39248       };
39249     } catch (std::exception& e) {
39250       {
39251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39252       };
39253     } catch (Dali::DaliException e) {
39254       {
39255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39256       };
39257     } catch (...) {
39258       {
39259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39260       };
39261     }
39262   }
39263
39264 }
39265
39266
39267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39268   unsigned int jresult ;
39269   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39270   Dali::TouchEvent *arg2 = 0 ;
39271   bool result;
39272
39273   arg1 = (Dali::CustomActorImpl *)jarg1;
39274   arg2 = (Dali::TouchEvent *)jarg2;
39275   if (!arg2) {
39276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39277     return 0;
39278   }
39279   {
39280     try {
39281       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39282     } catch (std::out_of_range& e) {
39283       {
39284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39285       };
39286     } catch (std::exception& e) {
39287       {
39288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39289       };
39290     } catch (Dali::DaliException e) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39293       };
39294     } catch (...) {
39295       {
39296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39297       };
39298     }
39299   }
39300
39301   jresult = result;
39302   return jresult;
39303 }
39304
39305
39306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39307   unsigned int jresult ;
39308   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39309   Dali::HoverEvent *arg2 = 0 ;
39310   bool result;
39311
39312   arg1 = (Dali::CustomActorImpl *)jarg1;
39313   arg2 = (Dali::HoverEvent *)jarg2;
39314   if (!arg2) {
39315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39316     return 0;
39317   }
39318   {
39319     try {
39320       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39321     } catch (std::out_of_range& e) {
39322       {
39323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39324       };
39325     } catch (std::exception& e) {
39326       {
39327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39328       };
39329     } catch (Dali::DaliException e) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39332       };
39333     } catch (...) {
39334       {
39335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39336       };
39337     }
39338   }
39339
39340   jresult = result;
39341   return jresult;
39342 }
39343
39344
39345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39346   unsigned int jresult ;
39347   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39348   Dali::KeyEvent *arg2 = 0 ;
39349   bool result;
39350
39351   arg1 = (Dali::CustomActorImpl *)jarg1;
39352   arg2 = (Dali::KeyEvent *)jarg2;
39353   if (!arg2) {
39354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39355     return 0;
39356   }
39357   {
39358     try {
39359       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39360     } catch (std::out_of_range& e) {
39361       {
39362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39363       };
39364     } catch (std::exception& e) {
39365       {
39366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (Dali::DaliException e) {
39369       {
39370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39375       };
39376     }
39377   }
39378
39379   jresult = result;
39380   return jresult;
39381 }
39382
39383
39384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39385   unsigned int jresult ;
39386   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39387   Dali::WheelEvent *arg2 = 0 ;
39388   bool result;
39389
39390   arg1 = (Dali::CustomActorImpl *)jarg1;
39391   arg2 = (Dali::WheelEvent *)jarg2;
39392   if (!arg2) {
39393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39394     return 0;
39395   }
39396   {
39397     try {
39398       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39399     } catch (std::out_of_range& e) {
39400       {
39401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39402       };
39403     } catch (std::exception& e) {
39404       {
39405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39406       };
39407     } catch (Dali::DaliException e) {
39408       {
39409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39410       };
39411     } catch (...) {
39412       {
39413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39414       };
39415     }
39416   }
39417
39418   jresult = result;
39419   return jresult;
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39424   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39425   Dali::Vector2 *arg2 = 0 ;
39426   Dali::RelayoutContainer *arg3 = 0 ;
39427
39428   arg1 = (Dali::CustomActorImpl *)jarg1;
39429   arg2 = (Dali::Vector2 *)jarg2;
39430   if (!arg2) {
39431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39432     return ;
39433   }
39434   arg3 = (Dali::RelayoutContainer *)jarg3;
39435   if (!arg3) {
39436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39437     return ;
39438   }
39439   {
39440     try {
39441       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39442     } catch (std::out_of_range& e) {
39443       {
39444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39445       };
39446     } catch (std::exception& e) {
39447       {
39448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39449       };
39450     } catch (Dali::DaliException e) {
39451       {
39452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39453       };
39454     } catch (...) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39457       };
39458     }
39459   }
39460
39461 }
39462
39463
39464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39465   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39466   Dali::ResizePolicy::Type arg2 ;
39467   Dali::Dimension::Type arg3 ;
39468
39469   arg1 = (Dali::CustomActorImpl *)jarg1;
39470   arg2 = (Dali::ResizePolicy::Type)jarg2;
39471   arg3 = (Dali::Dimension::Type)jarg3;
39472   {
39473     try {
39474       (arg1)->OnSetResizePolicy(arg2,arg3);
39475     } catch (std::out_of_range& e) {
39476       {
39477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39478       };
39479     } catch (std::exception& e) {
39480       {
39481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39482       };
39483     } catch (Dali::DaliException e) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39486       };
39487     } catch (...) {
39488       {
39489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39490       };
39491     }
39492   }
39493
39494 }
39495
39496
39497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39498   void * jresult ;
39499   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39500   Dali::Vector3 result;
39501
39502   arg1 = (Dali::CustomActorImpl *)jarg1;
39503   {
39504     try {
39505       result = (arg1)->GetNaturalSize();
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39521       };
39522     }
39523   }
39524
39525   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39526   return jresult;
39527 }
39528
39529
39530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39531   float jresult ;
39532   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39533   Dali::Actor *arg2 = 0 ;
39534   Dali::Dimension::Type arg3 ;
39535   float result;
39536
39537   arg1 = (Dali::CustomActorImpl *)jarg1;
39538   arg2 = (Dali::Actor *)jarg2;
39539   if (!arg2) {
39540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39541     return 0;
39542   }
39543   arg3 = (Dali::Dimension::Type)jarg3;
39544   {
39545     try {
39546       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39547     } catch (std::out_of_range& e) {
39548       {
39549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39550       };
39551     } catch (std::exception& e) {
39552       {
39553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39554       };
39555     } catch (Dali::DaliException e) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39558       };
39559     } catch (...) {
39560       {
39561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39562       };
39563     }
39564   }
39565
39566   jresult = result;
39567   return jresult;
39568 }
39569
39570
39571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39572   float jresult ;
39573   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39574   float arg2 ;
39575   float result;
39576
39577   arg1 = (Dali::CustomActorImpl *)jarg1;
39578   arg2 = (float)jarg2;
39579   {
39580     try {
39581       result = (float)(arg1)->GetHeightForWidth(arg2);
39582     } catch (std::out_of_range& e) {
39583       {
39584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (std::exception& e) {
39587       {
39588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39589       };
39590     } catch (Dali::DaliException e) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39597       };
39598     }
39599   }
39600
39601   jresult = result;
39602   return jresult;
39603 }
39604
39605
39606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39607   float jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   float arg2 ;
39610   float result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (float)jarg2;
39614   {
39615     try {
39616       result = (float)(arg1)->GetWidthForHeight(arg2);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (Dali::DaliException e) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39632       };
39633     }
39634   }
39635
39636   jresult = result;
39637   return jresult;
39638 }
39639
39640
39641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39642   unsigned int jresult ;
39643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39644   Dali::Dimension::Type arg2 ;
39645   bool result;
39646
39647   arg1 = (Dali::CustomActorImpl *)jarg1;
39648   arg2 = (Dali::Dimension::Type)jarg2;
39649   {
39650     try {
39651       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39667       };
39668     }
39669   }
39670
39671   jresult = result;
39672   return jresult;
39673 }
39674
39675
39676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39677   unsigned int jresult ;
39678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39679   bool result;
39680
39681   arg1 = (Dali::CustomActorImpl *)jarg1;
39682   {
39683     try {
39684       result = (bool)(arg1)->RelayoutDependentOnChildren();
39685     } catch (std::out_of_range& e) {
39686       {
39687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39688       };
39689     } catch (std::exception& e) {
39690       {
39691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39692       };
39693     } catch (Dali::DaliException e) {
39694       {
39695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39696       };
39697     } catch (...) {
39698       {
39699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39700       };
39701     }
39702   }
39703
39704   jresult = result;
39705   return jresult;
39706 }
39707
39708
39709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39710   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39711   Dali::Dimension::Type arg2 ;
39712
39713   arg1 = (Dali::CustomActorImpl *)jarg1;
39714   arg2 = (Dali::Dimension::Type)jarg2;
39715   {
39716     try {
39717       (arg1)->OnCalculateRelayoutSize(arg2);
39718     } catch (std::out_of_range& e) {
39719       {
39720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39721       };
39722     } catch (std::exception& e) {
39723       {
39724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39725       };
39726     } catch (Dali::DaliException e) {
39727       {
39728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39733       };
39734     }
39735   }
39736
39737 }
39738
39739
39740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39741   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39742   float arg2 ;
39743   Dali::Dimension::Type arg3 ;
39744
39745   arg1 = (Dali::CustomActorImpl *)jarg1;
39746   arg2 = (float)jarg2;
39747   arg3 = (Dali::Dimension::Type)jarg3;
39748   {
39749     try {
39750       (arg1)->OnLayoutNegotiated(arg2,arg3);
39751     } catch (std::out_of_range& e) {
39752       {
39753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39754       };
39755     } catch (std::exception& e) {
39756       {
39757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (Dali::DaliException e) {
39760       {
39761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769
39770 }
39771
39772
39773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39774   unsigned int jresult ;
39775   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39776   bool result;
39777
39778   arg1 = (Dali::CustomActorImpl *)jarg1;
39779   {
39780     try {
39781       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39782     } catch (std::out_of_range& e) {
39783       {
39784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39785       };
39786     } catch (std::exception& e) {
39787       {
39788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39789       };
39790     } catch (Dali::DaliException e) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39797       };
39798     }
39799   }
39800
39801   jresult = result;
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39807   unsigned int jresult ;
39808   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39809   bool result;
39810
39811   arg1 = (Dali::CustomActorImpl *)jarg1;
39812   {
39813     try {
39814       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39815     } catch (std::out_of_range& e) {
39816       {
39817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39818       };
39819     } catch (std::exception& e) {
39820       {
39821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39822       };
39823     } catch (Dali::DaliException e) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39826       };
39827     } catch (...) {
39828       {
39829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39830       };
39831     }
39832   }
39833
39834   jresult = result;
39835   return jresult;
39836 }
39837
39838
39839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39840   unsigned int jresult ;
39841   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39842   bool result;
39843
39844   arg1 = (Dali::CustomActorImpl *)jarg1;
39845   {
39846     try {
39847       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39848     } catch (std::out_of_range& e) {
39849       {
39850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39851       };
39852     } catch (std::exception& e) {
39853       {
39854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39855       };
39856     } catch (Dali::DaliException e) {
39857       {
39858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39859       };
39860     } catch (...) {
39861       {
39862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39863       };
39864     }
39865   }
39866
39867   jresult = result;
39868   return jresult;
39869 }
39870
39871
39872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39873   unsigned int jresult ;
39874   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39875   bool result;
39876
39877   arg1 = (Dali::CustomActorImpl *)jarg1;
39878   {
39879     try {
39880       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39881     } catch (std::out_of_range& e) {
39882       {
39883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39884       };
39885     } catch (std::exception& e) {
39886       {
39887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39888       };
39889     } catch (Dali::DaliException e) {
39890       {
39891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39892       };
39893     } catch (...) {
39894       {
39895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39896       };
39897     }
39898   }
39899
39900   jresult = result;
39901   return jresult;
39902 }
39903
39904
39905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39906   void * jresult ;
39907   Dali::CustomActor *result = 0 ;
39908
39909   {
39910     try {
39911       result = (Dali::CustomActor *)new Dali::CustomActor();
39912     } catch (std::out_of_range& e) {
39913       {
39914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39915       };
39916     } catch (std::exception& e) {
39917       {
39918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39919       };
39920     } catch (Dali::DaliException e) {
39921       {
39922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39923       };
39924     } catch (...) {
39925       {
39926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39927       };
39928     }
39929   }
39930
39931   jresult = (void *)result;
39932   return jresult;
39933 }
39934
39935
39936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39937   void * jresult ;
39938   Dali::BaseHandle arg1 ;
39939   Dali::BaseHandle *argp1 ;
39940   Dali::CustomActor result;
39941
39942   argp1 = (Dali::BaseHandle *)jarg1;
39943   if (!argp1) {
39944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39945     return 0;
39946   }
39947   arg1 = *argp1;
39948   {
39949     try {
39950       result = Dali::CustomActor::DownCast(arg1);
39951     } catch (std::out_of_range& e) {
39952       {
39953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39954       };
39955     } catch (std::exception& e) {
39956       {
39957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39958       };
39959     } catch (Dali::DaliException e) {
39960       {
39961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39962       };
39963     } catch (...) {
39964       {
39965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39966       };
39967     }
39968   }
39969
39970   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39971   return jresult;
39972 }
39973
39974
39975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39976   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39977
39978   arg1 = (Dali::CustomActor *)jarg1;
39979   {
39980     try {
39981       delete arg1;
39982     } catch (std::out_of_range& e) {
39983       {
39984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39985       };
39986     } catch (std::exception& e) {
39987       {
39988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39989       };
39990     } catch (Dali::DaliException e) {
39991       {
39992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39993       };
39994     } catch (...) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39997       };
39998     }
39999   }
40000
40001 }
40002
40003
40004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40005   void * jresult ;
40006   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40007   Dali::CustomActorImpl *result = 0 ;
40008
40009   arg1 = (Dali::CustomActor *)jarg1;
40010   {
40011     try {
40012       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40013     } catch (std::out_of_range& e) {
40014       {
40015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40016       };
40017     } catch (std::exception& e) {
40018       {
40019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40020       };
40021     } catch (Dali::DaliException e) {
40022       {
40023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40024       };
40025     } catch (...) {
40026       {
40027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40028       };
40029     }
40030   }
40031
40032   jresult = (void *)result;
40033   return jresult;
40034 }
40035
40036
40037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40038   void * jresult ;
40039   Dali::CustomActorImpl *arg1 = 0 ;
40040   Dali::CustomActor *result = 0 ;
40041
40042   arg1 = (Dali::CustomActorImpl *)jarg1;
40043   if (!arg1) {
40044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40045     return 0;
40046   }
40047   {
40048     try {
40049       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40050     } catch (std::out_of_range& e) {
40051       {
40052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40053       };
40054     } catch (std::exception& e) {
40055       {
40056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40057       };
40058     } catch (Dali::DaliException e) {
40059       {
40060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40061       };
40062     } catch (...) {
40063       {
40064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40065       };
40066     }
40067   }
40068
40069   jresult = (void *)result;
40070   return jresult;
40071 }
40072
40073
40074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40075   void * jresult ;
40076   Dali::CustomActor *arg1 = 0 ;
40077   Dali::CustomActor *result = 0 ;
40078
40079   arg1 = (Dali::CustomActor *)jarg1;
40080   if (!arg1) {
40081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40082     return 0;
40083   }
40084   {
40085     try {
40086       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40087     } catch (std::out_of_range& e) {
40088       {
40089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (std::exception& e) {
40092       {
40093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40094       };
40095     } catch (Dali::DaliException e) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40098       };
40099     } catch (...) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40102       };
40103     }
40104   }
40105
40106   jresult = (void *)result;
40107   return jresult;
40108 }
40109
40110
40111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40112   void * jresult ;
40113   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40114   Dali::CustomActor *arg2 = 0 ;
40115   Dali::CustomActor *result = 0 ;
40116
40117   arg1 = (Dali::CustomActor *)jarg1;
40118   arg2 = (Dali::CustomActor *)jarg2;
40119   if (!arg2) {
40120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40121     return 0;
40122   }
40123   {
40124     try {
40125       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40126     } catch (std::out_of_range& e) {
40127       {
40128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (std::exception& e) {
40131       {
40132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (Dali::DaliException e) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40137       };
40138     } catch (...) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40141       };
40142     }
40143   }
40144
40145   jresult = (void *)result;
40146   return jresult;
40147 }
40148
40149
40150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40151   int jresult ;
40152   int result;
40153
40154   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40155   jresult = (int)result;
40156   return jresult;
40157 }
40158
40159
40160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40161   int jresult ;
40162   int result;
40163
40164   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40165   jresult = (int)result;
40166   return jresult;
40167 }
40168
40169
40170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40171   int jresult ;
40172   int result;
40173
40174   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40175   jresult = (int)result;
40176   return jresult;
40177 }
40178
40179
40180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40181   int jresult ;
40182   int result;
40183
40184   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40185   jresult = (int)result;
40186   return jresult;
40187 }
40188
40189
40190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40191   int jresult ;
40192   int result;
40193
40194   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40195   jresult = (int)result;
40196   return jresult;
40197 }
40198
40199
40200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40201   int jresult ;
40202   int result;
40203
40204   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40205   jresult = (int)result;
40206   return jresult;
40207 }
40208
40209
40210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40211   int jresult ;
40212   int result;
40213
40214   result = (int)Dali::PanGestureDetector::Property::PANNING;
40215   jresult = (int)result;
40216   return jresult;
40217 }
40218
40219
40220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40221   void * jresult ;
40222   Dali::PanGestureDetector::Property *result = 0 ;
40223
40224   {
40225     try {
40226       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40227     } catch (std::out_of_range& e) {
40228       {
40229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40230       };
40231     } catch (std::exception& e) {
40232       {
40233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (Dali::DaliException e) {
40236       {
40237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40238       };
40239     } catch (...) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40242       };
40243     }
40244   }
40245
40246   jresult = (void *)result;
40247   return jresult;
40248 }
40249
40250
40251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40252   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40253
40254   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40255   {
40256     try {
40257       delete arg1;
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40265       };
40266     } catch (Dali::DaliException e) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40269       };
40270     } catch (...) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40273       };
40274     }
40275   }
40276
40277 }
40278
40279
40280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40281   void * jresult ;
40282   Dali::Radian *result = 0 ;
40283
40284   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40285   jresult = (void *)result;
40286   return jresult;
40287 }
40288
40289
40290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40291   void * jresult ;
40292   Dali::Radian *result = 0 ;
40293
40294   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40295   jresult = (void *)result;
40296   return jresult;
40297 }
40298
40299
40300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40301   void * jresult ;
40302   Dali::Radian *result = 0 ;
40303
40304   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40305   jresult = (void *)result;
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40311   void * jresult ;
40312   Dali::Radian *result = 0 ;
40313
40314   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40315   jresult = (void *)result;
40316   return jresult;
40317 }
40318
40319
40320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40321   void * jresult ;
40322   Dali::Radian *result = 0 ;
40323
40324   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40325   jresult = (void *)result;
40326   return jresult;
40327 }
40328
40329
40330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40331   void * jresult ;
40332   Dali::Radian *result = 0 ;
40333
40334   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40335   jresult = (void *)result;
40336   return jresult;
40337 }
40338
40339
40340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40341   void * jresult ;
40342   Dali::Radian *result = 0 ;
40343
40344   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40345   jresult = (void *)result;
40346   return jresult;
40347 }
40348
40349
40350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40351   void * jresult ;
40352   Dali::PanGestureDetector *result = 0 ;
40353
40354   {
40355     try {
40356       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40357     } catch (std::out_of_range& e) {
40358       {
40359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40360       };
40361     } catch (std::exception& e) {
40362       {
40363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40364       };
40365     } catch (Dali::DaliException e) {
40366       {
40367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40368       };
40369     } catch (...) {
40370       {
40371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40372       };
40373     }
40374   }
40375
40376   jresult = (void *)result;
40377   return jresult;
40378 }
40379
40380
40381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40382   void * jresult ;
40383   Dali::PanGestureDetector result;
40384
40385   {
40386     try {
40387       result = Dali::PanGestureDetector::New();
40388     } catch (std::out_of_range& e) {
40389       {
40390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40391       };
40392     } catch (std::exception& e) {
40393       {
40394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40395       };
40396     } catch (Dali::DaliException e) {
40397       {
40398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40403       };
40404     }
40405   }
40406
40407   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40413   void * jresult ;
40414   Dali::BaseHandle arg1 ;
40415   Dali::BaseHandle *argp1 ;
40416   Dali::PanGestureDetector result;
40417
40418   argp1 = (Dali::BaseHandle *)jarg1;
40419   if (!argp1) {
40420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40421     return 0;
40422   }
40423   arg1 = *argp1;
40424   {
40425     try {
40426       result = Dali::PanGestureDetector::DownCast(arg1);
40427     } catch (std::out_of_range& e) {
40428       {
40429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (std::exception& e) {
40432       {
40433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40434       };
40435     } catch (Dali::DaliException e) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40438       };
40439     } catch (...) {
40440       {
40441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40442       };
40443     }
40444   }
40445
40446   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40453
40454   arg1 = (Dali::PanGestureDetector *)jarg1;
40455   {
40456     try {
40457       delete arg1;
40458     } catch (std::out_of_range& e) {
40459       {
40460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40461       };
40462     } catch (std::exception& e) {
40463       {
40464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40465       };
40466     } catch (Dali::DaliException e) {
40467       {
40468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40469       };
40470     } catch (...) {
40471       {
40472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40473       };
40474     }
40475   }
40476
40477 }
40478
40479
40480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40481   void * jresult ;
40482   Dali::PanGestureDetector *arg1 = 0 ;
40483   Dali::PanGestureDetector *result = 0 ;
40484
40485   arg1 = (Dali::PanGestureDetector *)jarg1;
40486   if (!arg1) {
40487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40488     return 0;
40489   }
40490   {
40491     try {
40492       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40493     } catch (std::out_of_range& e) {
40494       {
40495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40496       };
40497     } catch (std::exception& e) {
40498       {
40499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40500       };
40501     } catch (Dali::DaliException e) {
40502       {
40503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40504       };
40505     } catch (...) {
40506       {
40507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40508       };
40509     }
40510   }
40511
40512   jresult = (void *)result;
40513   return jresult;
40514 }
40515
40516
40517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40518   void * jresult ;
40519   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40520   Dali::PanGestureDetector *arg2 = 0 ;
40521   Dali::PanGestureDetector *result = 0 ;
40522
40523   arg1 = (Dali::PanGestureDetector *)jarg1;
40524   arg2 = (Dali::PanGestureDetector *)jarg2;
40525   if (!arg2) {
40526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40527     return 0;
40528   }
40529   {
40530     try {
40531       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (Dali::DaliException e) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550
40551   jresult = (void *)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40557   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40558   unsigned int arg2 ;
40559
40560   arg1 = (Dali::PanGestureDetector *)jarg1;
40561   arg2 = (unsigned int)jarg2;
40562   {
40563     try {
40564       (arg1)->SetMinimumTouchesRequired(arg2);
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40572       };
40573     } catch (Dali::DaliException e) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40576       };
40577     } catch (...) {
40578       {
40579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40580       };
40581     }
40582   }
40583
40584 }
40585
40586
40587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40588   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40589   unsigned int arg2 ;
40590
40591   arg1 = (Dali::PanGestureDetector *)jarg1;
40592   arg2 = (unsigned int)jarg2;
40593   {
40594     try {
40595       (arg1)->SetMaximumTouchesRequired(arg2);
40596     } catch (std::out_of_range& e) {
40597       {
40598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40599       };
40600     } catch (std::exception& e) {
40601       {
40602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40603       };
40604     } catch (Dali::DaliException e) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40611       };
40612     }
40613   }
40614
40615 }
40616
40617
40618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40619   unsigned int jresult ;
40620   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40621   unsigned int result;
40622
40623   arg1 = (Dali::PanGestureDetector *)jarg1;
40624   {
40625     try {
40626       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40627     } catch (std::out_of_range& e) {
40628       {
40629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40630       };
40631     } catch (std::exception& e) {
40632       {
40633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40634       };
40635     } catch (Dali::DaliException e) {
40636       {
40637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40638       };
40639     } catch (...) {
40640       {
40641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40642       };
40643     }
40644   }
40645
40646   jresult = result;
40647   return jresult;
40648 }
40649
40650
40651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40652   unsigned int jresult ;
40653   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40654   unsigned int result;
40655
40656   arg1 = (Dali::PanGestureDetector *)jarg1;
40657   {
40658     try {
40659       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40660     } catch (std::out_of_range& e) {
40661       {
40662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40663       };
40664     } catch (std::exception& e) {
40665       {
40666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40667       };
40668     } catch (Dali::DaliException e) {
40669       {
40670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40671       };
40672     } catch (...) {
40673       {
40674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40675       };
40676     }
40677   }
40678
40679   jresult = result;
40680   return jresult;
40681 }
40682
40683
40684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40685   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40686   Dali::Radian arg2 ;
40687   Dali::Radian arg3 ;
40688   Dali::Radian *argp2 ;
40689   Dali::Radian *argp3 ;
40690
40691   arg1 = (Dali::PanGestureDetector *)jarg1;
40692   argp2 = (Dali::Radian *)jarg2;
40693   if (!argp2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40695     return ;
40696   }
40697   arg2 = *argp2;
40698   argp3 = (Dali::Radian *)jarg3;
40699   if (!argp3) {
40700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40701     return ;
40702   }
40703   arg3 = *argp3;
40704   {
40705     try {
40706       (arg1)->AddAngle(arg2,arg3);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40722       };
40723     }
40724   }
40725
40726 }
40727
40728
40729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40730   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40731   Dali::Radian arg2 ;
40732   Dali::Radian *argp2 ;
40733
40734   arg1 = (Dali::PanGestureDetector *)jarg1;
40735   argp2 = (Dali::Radian *)jarg2;
40736   if (!argp2) {
40737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40738     return ;
40739   }
40740   arg2 = *argp2;
40741   {
40742     try {
40743       (arg1)->AddAngle(arg2);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40759       };
40760     }
40761   }
40762
40763 }
40764
40765
40766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40767   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40768   Dali::Radian arg2 ;
40769   Dali::Radian arg3 ;
40770   Dali::Radian *argp2 ;
40771   Dali::Radian *argp3 ;
40772
40773   arg1 = (Dali::PanGestureDetector *)jarg1;
40774   argp2 = (Dali::Radian *)jarg2;
40775   if (!argp2) {
40776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40777     return ;
40778   }
40779   arg2 = *argp2;
40780   argp3 = (Dali::Radian *)jarg3;
40781   if (!argp3) {
40782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40783     return ;
40784   }
40785   arg3 = *argp3;
40786   {
40787     try {
40788       (arg1)->AddDirection(arg2,arg3);
40789     } catch (std::out_of_range& e) {
40790       {
40791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40792       };
40793     } catch (std::exception& e) {
40794       {
40795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40796       };
40797     } catch (Dali::DaliException e) {
40798       {
40799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40800       };
40801     } catch (...) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40804       };
40805     }
40806   }
40807
40808 }
40809
40810
40811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40812   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40813   Dali::Radian arg2 ;
40814   Dali::Radian *argp2 ;
40815
40816   arg1 = (Dali::PanGestureDetector *)jarg1;
40817   argp2 = (Dali::Radian *)jarg2;
40818   if (!argp2) {
40819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40820     return ;
40821   }
40822   arg2 = *argp2;
40823   {
40824     try {
40825       (arg1)->AddDirection(arg2);
40826     } catch (std::out_of_range& e) {
40827       {
40828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (std::exception& e) {
40831       {
40832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40833       };
40834     } catch (Dali::DaliException e) {
40835       {
40836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40837       };
40838     } catch (...) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40841       };
40842     }
40843   }
40844
40845 }
40846
40847
40848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40849   unsigned long jresult ;
40850   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40851   size_t result;
40852
40853   arg1 = (Dali::PanGestureDetector *)jarg1;
40854   {
40855     try {
40856       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40857     } catch (std::out_of_range& e) {
40858       {
40859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40860       };
40861     } catch (std::exception& e) {
40862       {
40863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40864       };
40865     } catch (Dali::DaliException e) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40868       };
40869     } catch (...) {
40870       {
40871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40872       };
40873     }
40874   }
40875
40876   jresult = (unsigned long)result;
40877   return jresult;
40878 }
40879
40880
40881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40882   void * jresult ;
40883   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40884   size_t arg2 ;
40885   Dali::PanGestureDetector::AngleThresholdPair result;
40886
40887   arg1 = (Dali::PanGestureDetector *)jarg1;
40888   arg2 = (size_t)jarg2;
40889   {
40890     try {
40891       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40892     } catch (std::out_of_range& e) {
40893       {
40894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40895       };
40896     } catch (std::exception& e) {
40897       {
40898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40899       };
40900     } catch (Dali::DaliException e) {
40901       {
40902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40903       };
40904     } catch (...) {
40905       {
40906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40907       };
40908     }
40909   }
40910
40911   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40917   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40918
40919   arg1 = (Dali::PanGestureDetector *)jarg1;
40920   {
40921     try {
40922       (arg1)->ClearAngles();
40923     } catch (std::out_of_range& e) {
40924       {
40925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40926       };
40927     } catch (std::exception& e) {
40928       {
40929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40930       };
40931     } catch (Dali::DaliException e) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40934       };
40935     } catch (...) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40938       };
40939     }
40940   }
40941
40942 }
40943
40944
40945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40946   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40947   Dali::Radian arg2 ;
40948   Dali::Radian *argp2 ;
40949
40950   arg1 = (Dali::PanGestureDetector *)jarg1;
40951   argp2 = (Dali::Radian *)jarg2;
40952   if (!argp2) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40954     return ;
40955   }
40956   arg2 = *argp2;
40957   {
40958     try {
40959       (arg1)->RemoveAngle(arg2);
40960     } catch (std::out_of_range& e) {
40961       {
40962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40963       };
40964     } catch (std::exception& e) {
40965       {
40966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (Dali::DaliException e) {
40969       {
40970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40971       };
40972     } catch (...) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40975       };
40976     }
40977   }
40978
40979 }
40980
40981
40982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40983   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40984   Dali::Radian arg2 ;
40985   Dali::Radian *argp2 ;
40986
40987   arg1 = (Dali::PanGestureDetector *)jarg1;
40988   argp2 = (Dali::Radian *)jarg2;
40989   if (!argp2) {
40990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40991     return ;
40992   }
40993   arg2 = *argp2;
40994   {
40995     try {
40996       (arg1)->RemoveDirection(arg2);
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (Dali::DaliException e) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41012       };
41013     }
41014   }
41015
41016 }
41017
41018
41019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41020   void * jresult ;
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41023
41024   arg1 = (Dali::PanGestureDetector *)jarg1;
41025   {
41026     try {
41027       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41028     } catch (std::out_of_range& e) {
41029       {
41030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (std::exception& e) {
41033       {
41034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (Dali::DaliException e) {
41037       {
41038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41039       };
41040     } catch (...) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41043       };
41044     }
41045   }
41046
41047   jresult = (void *)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41053   Dali::PanGesture *arg1 = 0 ;
41054
41055   arg1 = (Dali::PanGesture *)jarg1;
41056   if (!arg1) {
41057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41058     return ;
41059   }
41060   {
41061     try {
41062       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41070       };
41071     } catch (Dali::DaliException e) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41074       };
41075     } catch (...) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41078       };
41079     }
41080   }
41081
41082 }
41083
41084
41085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41086   void * jresult ;
41087   Dali::PanGesture *result = 0 ;
41088
41089   {
41090     try {
41091       result = (Dali::PanGesture *)new Dali::PanGesture();
41092     } catch (std::out_of_range& e) {
41093       {
41094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41095       };
41096     } catch (std::exception& e) {
41097       {
41098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41099       };
41100     } catch (Dali::DaliException e) {
41101       {
41102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41103       };
41104     } catch (...) {
41105       {
41106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41107       };
41108     }
41109   }
41110
41111   jresult = (void *)result;
41112   return jresult;
41113 }
41114
41115
41116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41117   void * jresult ;
41118   Dali::Gesture::State arg1 ;
41119   Dali::PanGesture *result = 0 ;
41120
41121   arg1 = (Dali::Gesture::State)jarg1;
41122   {
41123     try {
41124       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (Dali::DaliException e) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41136       };
41137     } catch (...) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41140       };
41141     }
41142   }
41143
41144   jresult = (void *)result;
41145   return jresult;
41146 }
41147
41148
41149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41150   void * jresult ;
41151   Dali::PanGesture *arg1 = 0 ;
41152   Dali::PanGesture *result = 0 ;
41153
41154   arg1 = (Dali::PanGesture *)jarg1;
41155   if (!arg1) {
41156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41157     return 0;
41158   }
41159   {
41160     try {
41161       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41162     } catch (std::out_of_range& e) {
41163       {
41164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41165       };
41166     } catch (std::exception& e) {
41167       {
41168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41169       };
41170     } catch (Dali::DaliException e) {
41171       {
41172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41173       };
41174     } catch (...) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41177       };
41178     }
41179   }
41180
41181   jresult = (void *)result;
41182   return jresult;
41183 }
41184
41185
41186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41187   void * jresult ;
41188   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41189   Dali::PanGesture *arg2 = 0 ;
41190   Dali::PanGesture *result = 0 ;
41191
41192   arg1 = (Dali::PanGesture *)jarg1;
41193   arg2 = (Dali::PanGesture *)jarg2;
41194   if (!arg2) {
41195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41196     return 0;
41197   }
41198   {
41199     try {
41200       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41201     } catch (std::out_of_range& e) {
41202       {
41203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (std::exception& e) {
41206       {
41207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41208       };
41209     } catch (Dali::DaliException e) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41212       };
41213     } catch (...) {
41214       {
41215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41216       };
41217     }
41218   }
41219
41220   jresult = (void *)result;
41221   return jresult;
41222 }
41223
41224
41225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41227
41228   arg1 = (Dali::PanGesture *)jarg1;
41229   {
41230     try {
41231       delete arg1;
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41239       };
41240     } catch (Dali::DaliException e) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41243       };
41244     } catch (...) {
41245       {
41246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41247       };
41248     }
41249   }
41250
41251 }
41252
41253
41254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41255   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41256   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41257
41258   arg1 = (Dali::PanGesture *)jarg1;
41259   arg2 = (Dali::Vector2 *)jarg2;
41260   if (arg1) (arg1)->velocity = *arg2;
41261 }
41262
41263
41264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41265   void * jresult ;
41266   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41267   Dali::Vector2 *result = 0 ;
41268
41269   arg1 = (Dali::PanGesture *)jarg1;
41270   result = (Dali::Vector2 *)& ((arg1)->velocity);
41271   jresult = (void *)result;
41272   return jresult;
41273 }
41274
41275
41276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41277   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41278   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41279
41280   arg1 = (Dali::PanGesture *)jarg1;
41281   arg2 = (Dali::Vector2 *)jarg2;
41282   if (arg1) (arg1)->displacement = *arg2;
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41287   void * jresult ;
41288   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41289   Dali::Vector2 *result = 0 ;
41290
41291   arg1 = (Dali::PanGesture *)jarg1;
41292   result = (Dali::Vector2 *)& ((arg1)->displacement);
41293   jresult = (void *)result;
41294   return jresult;
41295 }
41296
41297
41298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41299   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41300   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41301
41302   arg1 = (Dali::PanGesture *)jarg1;
41303   arg2 = (Dali::Vector2 *)jarg2;
41304   if (arg1) (arg1)->position = *arg2;
41305 }
41306
41307
41308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41309   void * jresult ;
41310   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41311   Dali::Vector2 *result = 0 ;
41312
41313   arg1 = (Dali::PanGesture *)jarg1;
41314   result = (Dali::Vector2 *)& ((arg1)->position);
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41321   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41322   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41323
41324   arg1 = (Dali::PanGesture *)jarg1;
41325   arg2 = (Dali::Vector2 *)jarg2;
41326   if (arg1) (arg1)->screenVelocity = *arg2;
41327 }
41328
41329
41330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41331   void * jresult ;
41332   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41333   Dali::Vector2 *result = 0 ;
41334
41335   arg1 = (Dali::PanGesture *)jarg1;
41336   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41337   jresult = (void *)result;
41338   return jresult;
41339 }
41340
41341
41342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41343   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41344   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41345
41346   arg1 = (Dali::PanGesture *)jarg1;
41347   arg2 = (Dali::Vector2 *)jarg2;
41348   if (arg1) (arg1)->screenDisplacement = *arg2;
41349 }
41350
41351
41352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41353   void * jresult ;
41354   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41355   Dali::Vector2 *result = 0 ;
41356
41357   arg1 = (Dali::PanGesture *)jarg1;
41358   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41359   jresult = (void *)result;
41360   return jresult;
41361 }
41362
41363
41364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41365   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41366   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41367
41368   arg1 = (Dali::PanGesture *)jarg1;
41369   arg2 = (Dali::Vector2 *)jarg2;
41370   if (arg1) (arg1)->screenPosition = *arg2;
41371 }
41372
41373
41374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41375   void * jresult ;
41376   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41377   Dali::Vector2 *result = 0 ;
41378
41379   arg1 = (Dali::PanGesture *)jarg1;
41380   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41381   jresult = (void *)result;
41382   return jresult;
41383 }
41384
41385
41386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41387   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41388   unsigned int arg2 ;
41389
41390   arg1 = (Dali::PanGesture *)jarg1;
41391   arg2 = (unsigned int)jarg2;
41392   if (arg1) (arg1)->numberOfTouches = arg2;
41393 }
41394
41395
41396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41397   unsigned int jresult ;
41398   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41399   unsigned int result;
41400
41401   arg1 = (Dali::PanGesture *)jarg1;
41402   result = (unsigned int) ((arg1)->numberOfTouches);
41403   jresult = result;
41404   return jresult;
41405 }
41406
41407
41408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41409   float jresult ;
41410   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41411   float result;
41412
41413   arg1 = (Dali::PanGesture *)jarg1;
41414   {
41415     try {
41416       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41417     } catch (std::out_of_range& e) {
41418       {
41419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41420       };
41421     } catch (std::exception& e) {
41422       {
41423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41424       };
41425     } catch (Dali::DaliException e) {
41426       {
41427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41428       };
41429     } catch (...) {
41430       {
41431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41432       };
41433     }
41434   }
41435
41436   jresult = result;
41437   return jresult;
41438 }
41439
41440
41441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41442   float jresult ;
41443   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41444   float result;
41445
41446   arg1 = (Dali::PanGesture *)jarg1;
41447   {
41448     try {
41449       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41450     } catch (std::out_of_range& e) {
41451       {
41452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41453       };
41454     } catch (std::exception& e) {
41455       {
41456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41457       };
41458     } catch (Dali::DaliException e) {
41459       {
41460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41461       };
41462     } catch (...) {
41463       {
41464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41465       };
41466     }
41467   }
41468
41469   jresult = result;
41470   return jresult;
41471 }
41472
41473
41474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41475   float jresult ;
41476   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41477   float result;
41478
41479   arg1 = (Dali::PanGesture *)jarg1;
41480   {
41481     try {
41482       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41483     } catch (std::out_of_range& e) {
41484       {
41485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41486       };
41487     } catch (std::exception& e) {
41488       {
41489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41490       };
41491     } catch (Dali::DaliException e) {
41492       {
41493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41494       };
41495     } catch (...) {
41496       {
41497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41498       };
41499     }
41500   }
41501
41502   jresult = result;
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41508   float jresult ;
41509   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41510   float result;
41511
41512   arg1 = (Dali::PanGesture *)jarg1;
41513   {
41514     try {
41515       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41516     } catch (std::out_of_range& e) {
41517       {
41518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41519       };
41520     } catch (std::exception& e) {
41521       {
41522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41523       };
41524     } catch (Dali::DaliException e) {
41525       {
41526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41527       };
41528     } catch (...) {
41529       {
41530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41531       };
41532     }
41533   }
41534
41535   jresult = result;
41536   return jresult;
41537 }
41538
41539
41540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41541   void * jresult ;
41542   Dali::PinchGestureDetector *result = 0 ;
41543
41544   {
41545     try {
41546       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41547     } catch (std::out_of_range& e) {
41548       {
41549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41550       };
41551     } catch (std::exception& e) {
41552       {
41553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41554       };
41555     } catch (Dali::DaliException e) {
41556       {
41557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41562       };
41563     }
41564   }
41565
41566   jresult = (void *)result;
41567   return jresult;
41568 }
41569
41570
41571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41572   void * jresult ;
41573   Dali::PinchGestureDetector result;
41574
41575   {
41576     try {
41577       result = Dali::PinchGestureDetector::New();
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (Dali::DaliException e) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41589       };
41590     } catch (...) {
41591       {
41592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41593       };
41594     }
41595   }
41596
41597   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41598   return jresult;
41599 }
41600
41601
41602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41603   void * jresult ;
41604   Dali::BaseHandle arg1 ;
41605   Dali::BaseHandle *argp1 ;
41606   Dali::PinchGestureDetector result;
41607
41608   argp1 = (Dali::BaseHandle *)jarg1;
41609   if (!argp1) {
41610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41611     return 0;
41612   }
41613   arg1 = *argp1;
41614   {
41615     try {
41616       result = Dali::PinchGestureDetector::DownCast(arg1);
41617     } catch (std::out_of_range& e) {
41618       {
41619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41620       };
41621     } catch (std::exception& e) {
41622       {
41623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (Dali::DaliException e) {
41626       {
41627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41628       };
41629     } catch (...) {
41630       {
41631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41632       };
41633     }
41634   }
41635
41636   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41637   return jresult;
41638 }
41639
41640
41641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41642   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41643
41644   arg1 = (Dali::PinchGestureDetector *)jarg1;
41645   {
41646     try {
41647       delete arg1;
41648     } catch (std::out_of_range& e) {
41649       {
41650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41651       };
41652     } catch (std::exception& e) {
41653       {
41654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41655       };
41656     } catch (Dali::DaliException e) {
41657       {
41658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41659       };
41660     } catch (...) {
41661       {
41662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41663       };
41664     }
41665   }
41666
41667 }
41668
41669
41670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41671   void * jresult ;
41672   Dali::PinchGestureDetector *arg1 = 0 ;
41673   Dali::PinchGestureDetector *result = 0 ;
41674
41675   arg1 = (Dali::PinchGestureDetector *)jarg1;
41676   if (!arg1) {
41677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41678     return 0;
41679   }
41680   {
41681     try {
41682       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41683     } catch (std::out_of_range& e) {
41684       {
41685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41686       };
41687     } catch (std::exception& e) {
41688       {
41689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41690       };
41691     } catch (Dali::DaliException e) {
41692       {
41693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41694       };
41695     } catch (...) {
41696       {
41697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41698       };
41699     }
41700   }
41701
41702   jresult = (void *)result;
41703   return jresult;
41704 }
41705
41706
41707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41708   void * jresult ;
41709   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41710   Dali::PinchGestureDetector *arg2 = 0 ;
41711   Dali::PinchGestureDetector *result = 0 ;
41712
41713   arg1 = (Dali::PinchGestureDetector *)jarg1;
41714   arg2 = (Dali::PinchGestureDetector *)jarg2;
41715   if (!arg2) {
41716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41717     return 0;
41718   }
41719   {
41720     try {
41721       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41722     } catch (std::out_of_range& e) {
41723       {
41724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (std::exception& e) {
41727       {
41728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41729       };
41730     } catch (Dali::DaliException e) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41733       };
41734     } catch (...) {
41735       {
41736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41737       };
41738     }
41739   }
41740
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41747   void * jresult ;
41748   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41749   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41750
41751   arg1 = (Dali::PinchGestureDetector *)jarg1;
41752   {
41753     try {
41754       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (Dali::DaliException e) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41766       };
41767     } catch (...) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41770       };
41771     }
41772   }
41773
41774   jresult = (void *)result;
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41780   void * jresult ;
41781   Dali::Gesture::State arg1 ;
41782   Dali::PinchGesture *result = 0 ;
41783
41784   arg1 = (Dali::Gesture::State)jarg1;
41785   {
41786     try {
41787       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (Dali::DaliException e) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41799       };
41800     } catch (...) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41803       };
41804     }
41805   }
41806
41807   jresult = (void *)result;
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41813   void * jresult ;
41814   Dali::PinchGesture *arg1 = 0 ;
41815   Dali::PinchGesture *result = 0 ;
41816
41817   arg1 = (Dali::PinchGesture *)jarg1;
41818   if (!arg1) {
41819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41820     return 0;
41821   }
41822   {
41823     try {
41824       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41825     } catch (std::out_of_range& e) {
41826       {
41827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41828       };
41829     } catch (std::exception& e) {
41830       {
41831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41832       };
41833     } catch (Dali::DaliException e) {
41834       {
41835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41836       };
41837     } catch (...) {
41838       {
41839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41840       };
41841     }
41842   }
41843
41844   jresult = (void *)result;
41845   return jresult;
41846 }
41847
41848
41849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41850   void * jresult ;
41851   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41852   Dali::PinchGesture *arg2 = 0 ;
41853   Dali::PinchGesture *result = 0 ;
41854
41855   arg1 = (Dali::PinchGesture *)jarg1;
41856   arg2 = (Dali::PinchGesture *)jarg2;
41857   if (!arg2) {
41858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41859     return 0;
41860   }
41861   {
41862     try {
41863       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41864     } catch (std::out_of_range& e) {
41865       {
41866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (std::exception& e) {
41869       {
41870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (Dali::DaliException e) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41875       };
41876     } catch (...) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41879       };
41880     }
41881   }
41882
41883   jresult = (void *)result;
41884   return jresult;
41885 }
41886
41887
41888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41889   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41890
41891   arg1 = (Dali::PinchGesture *)jarg1;
41892   {
41893     try {
41894       delete arg1;
41895     } catch (std::out_of_range& e) {
41896       {
41897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41898       };
41899     } catch (std::exception& e) {
41900       {
41901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41902       };
41903     } catch (Dali::DaliException e) {
41904       {
41905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41910       };
41911     }
41912   }
41913
41914 }
41915
41916
41917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41918   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41919   float arg2 ;
41920
41921   arg1 = (Dali::PinchGesture *)jarg1;
41922   arg2 = (float)jarg2;
41923   if (arg1) (arg1)->scale = arg2;
41924 }
41925
41926
41927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41928   float jresult ;
41929   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41930   float result;
41931
41932   arg1 = (Dali::PinchGesture *)jarg1;
41933   result = (float) ((arg1)->scale);
41934   jresult = result;
41935   return jresult;
41936 }
41937
41938
41939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41940   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41941   float arg2 ;
41942
41943   arg1 = (Dali::PinchGesture *)jarg1;
41944   arg2 = (float)jarg2;
41945   if (arg1) (arg1)->speed = arg2;
41946 }
41947
41948
41949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41950   float jresult ;
41951   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41952   float result;
41953
41954   arg1 = (Dali::PinchGesture *)jarg1;
41955   result = (float) ((arg1)->speed);
41956   jresult = result;
41957   return jresult;
41958 }
41959
41960
41961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41962   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41963   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41964
41965   arg1 = (Dali::PinchGesture *)jarg1;
41966   arg2 = (Dali::Vector2 *)jarg2;
41967   if (arg1) (arg1)->screenCenterPoint = *arg2;
41968 }
41969
41970
41971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41972   void * jresult ;
41973   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41974   Dali::Vector2 *result = 0 ;
41975
41976   arg1 = (Dali::PinchGesture *)jarg1;
41977   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41978   jresult = (void *)result;
41979   return jresult;
41980 }
41981
41982
41983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41984   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41985   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41986
41987   arg1 = (Dali::PinchGesture *)jarg1;
41988   arg2 = (Dali::Vector2 *)jarg2;
41989   if (arg1) (arg1)->localCenterPoint = *arg2;
41990 }
41991
41992
41993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41994   void * jresult ;
41995   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41996   Dali::Vector2 *result = 0 ;
41997
41998   arg1 = (Dali::PinchGesture *)jarg1;
41999   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42000   jresult = (void *)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42006   void * jresult ;
42007   Dali::TapGestureDetector *result = 0 ;
42008
42009   {
42010     try {
42011       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42012     } catch (std::out_of_range& e) {
42013       {
42014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42015       };
42016     } catch (std::exception& e) {
42017       {
42018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42019       };
42020     } catch (Dali::DaliException e) {
42021       {
42022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42023       };
42024     } catch (...) {
42025       {
42026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42027       };
42028     }
42029   }
42030
42031   jresult = (void *)result;
42032   return jresult;
42033 }
42034
42035
42036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42037   void * jresult ;
42038   Dali::TapGestureDetector result;
42039
42040   {
42041     try {
42042       result = Dali::TapGestureDetector::New();
42043     } catch (std::out_of_range& e) {
42044       {
42045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (std::exception& e) {
42048       {
42049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (Dali::DaliException e) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42054       };
42055     } catch (...) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42058       };
42059     }
42060   }
42061
42062   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42068   void * jresult ;
42069   unsigned int arg1 ;
42070   Dali::TapGestureDetector result;
42071
42072   arg1 = (unsigned int)jarg1;
42073   {
42074     try {
42075       result = Dali::TapGestureDetector::New(arg1);
42076     } catch (std::out_of_range& e) {
42077       {
42078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42079       };
42080     } catch (std::exception& e) {
42081       {
42082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42083       };
42084     } catch (Dali::DaliException e) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42087       };
42088     } catch (...) {
42089       {
42090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42091       };
42092     }
42093   }
42094
42095   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42096   return jresult;
42097 }
42098
42099
42100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42101   void * jresult ;
42102   Dali::BaseHandle arg1 ;
42103   Dali::BaseHandle *argp1 ;
42104   Dali::TapGestureDetector result;
42105
42106   argp1 = (Dali::BaseHandle *)jarg1;
42107   if (!argp1) {
42108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42109     return 0;
42110   }
42111   arg1 = *argp1;
42112   {
42113     try {
42114       result = Dali::TapGestureDetector::DownCast(arg1);
42115     } catch (std::out_of_range& e) {
42116       {
42117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42118       };
42119     } catch (std::exception& e) {
42120       {
42121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42122       };
42123     } catch (Dali::DaliException e) {
42124       {
42125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42126       };
42127     } catch (...) {
42128       {
42129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42130       };
42131     }
42132   }
42133
42134   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42135   return jresult;
42136 }
42137
42138
42139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42140   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42141
42142   arg1 = (Dali::TapGestureDetector *)jarg1;
42143   {
42144     try {
42145       delete arg1;
42146     } catch (std::out_of_range& e) {
42147       {
42148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42149       };
42150     } catch (std::exception& e) {
42151       {
42152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42153       };
42154     } catch (Dali::DaliException e) {
42155       {
42156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42157       };
42158     } catch (...) {
42159       {
42160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42161       };
42162     }
42163   }
42164
42165 }
42166
42167
42168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42169   void * jresult ;
42170   Dali::TapGestureDetector *arg1 = 0 ;
42171   Dali::TapGestureDetector *result = 0 ;
42172
42173   arg1 = (Dali::TapGestureDetector *)jarg1;
42174   if (!arg1) {
42175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42176     return 0;
42177   }
42178   {
42179     try {
42180       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42181     } catch (std::out_of_range& e) {
42182       {
42183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42184       };
42185     } catch (std::exception& e) {
42186       {
42187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (Dali::DaliException e) {
42190       {
42191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199
42200   jresult = (void *)result;
42201   return jresult;
42202 }
42203
42204
42205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42206   void * jresult ;
42207   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42208   Dali::TapGestureDetector *arg2 = 0 ;
42209   Dali::TapGestureDetector *result = 0 ;
42210
42211   arg1 = (Dali::TapGestureDetector *)jarg1;
42212   arg2 = (Dali::TapGestureDetector *)jarg2;
42213   if (!arg2) {
42214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42215     return 0;
42216   }
42217   {
42218     try {
42219       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42220     } catch (std::out_of_range& e) {
42221       {
42222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42223       };
42224     } catch (std::exception& e) {
42225       {
42226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42227       };
42228     } catch (Dali::DaliException e) {
42229       {
42230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42231       };
42232     } catch (...) {
42233       {
42234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42235       };
42236     }
42237   }
42238
42239   jresult = (void *)result;
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42245   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42246   unsigned int arg2 ;
42247
42248   arg1 = (Dali::TapGestureDetector *)jarg1;
42249   arg2 = (unsigned int)jarg2;
42250   {
42251     try {
42252       (arg1)->SetMinimumTapsRequired(arg2);
42253     } catch (std::out_of_range& e) {
42254       {
42255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42256       };
42257     } catch (std::exception& e) {
42258       {
42259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42260       };
42261     } catch (Dali::DaliException e) {
42262       {
42263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42268       };
42269     }
42270   }
42271
42272 }
42273
42274
42275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42276   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42277   unsigned int arg2 ;
42278
42279   arg1 = (Dali::TapGestureDetector *)jarg1;
42280   arg2 = (unsigned int)jarg2;
42281   {
42282     try {
42283       (arg1)->SetMaximumTapsRequired(arg2);
42284     } catch (std::out_of_range& e) {
42285       {
42286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42287       };
42288     } catch (std::exception& e) {
42289       {
42290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42291       };
42292     } catch (Dali::DaliException e) {
42293       {
42294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42295       };
42296     } catch (...) {
42297       {
42298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42299       };
42300     }
42301   }
42302
42303 }
42304
42305
42306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42307   unsigned int jresult ;
42308   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42309   unsigned int result;
42310
42311   arg1 = (Dali::TapGestureDetector *)jarg1;
42312   {
42313     try {
42314       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42315     } catch (std::out_of_range& e) {
42316       {
42317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (std::exception& e) {
42320       {
42321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42322       };
42323     } catch (Dali::DaliException e) {
42324       {
42325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42326       };
42327     } catch (...) {
42328       {
42329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42330       };
42331     }
42332   }
42333
42334   jresult = result;
42335   return jresult;
42336 }
42337
42338
42339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42340   unsigned int jresult ;
42341   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42342   unsigned int result;
42343
42344   arg1 = (Dali::TapGestureDetector *)jarg1;
42345   {
42346     try {
42347       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42348     } catch (std::out_of_range& e) {
42349       {
42350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42351       };
42352     } catch (std::exception& e) {
42353       {
42354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (Dali::DaliException e) {
42357       {
42358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42359       };
42360     } catch (...) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42363       };
42364     }
42365   }
42366
42367   jresult = result;
42368   return jresult;
42369 }
42370
42371
42372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42373   void * jresult ;
42374   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42375   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42376
42377   arg1 = (Dali::TapGestureDetector *)jarg1;
42378   {
42379     try {
42380       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42381     } catch (std::out_of_range& e) {
42382       {
42383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (std::exception& e) {
42386       {
42387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42388       };
42389     } catch (Dali::DaliException e) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42392       };
42393     } catch (...) {
42394       {
42395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42396       };
42397     }
42398   }
42399
42400   jresult = (void *)result;
42401   return jresult;
42402 }
42403
42404
42405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42406   void * jresult ;
42407   Dali::TapGesture *result = 0 ;
42408
42409   {
42410     try {
42411       result = (Dali::TapGesture *)new Dali::TapGesture();
42412     } catch (std::out_of_range& e) {
42413       {
42414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42415       };
42416     } catch (std::exception& e) {
42417       {
42418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (Dali::DaliException e) {
42421       {
42422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42423       };
42424     } catch (...) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42427       };
42428     }
42429   }
42430
42431   jresult = (void *)result;
42432   return jresult;
42433 }
42434
42435
42436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42437   void * jresult ;
42438   Dali::TapGesture *arg1 = 0 ;
42439   Dali::TapGesture *result = 0 ;
42440
42441   arg1 = (Dali::TapGesture *)jarg1;
42442   if (!arg1) {
42443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42444     return 0;
42445   }
42446   {
42447     try {
42448       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42449     } catch (std::out_of_range& e) {
42450       {
42451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (std::exception& e) {
42454       {
42455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42456       };
42457     } catch (Dali::DaliException e) {
42458       {
42459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42460       };
42461     } catch (...) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42464       };
42465     }
42466   }
42467
42468   jresult = (void *)result;
42469   return jresult;
42470 }
42471
42472
42473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42474   void * jresult ;
42475   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42476   Dali::TapGesture *arg2 = 0 ;
42477   Dali::TapGesture *result = 0 ;
42478
42479   arg1 = (Dali::TapGesture *)jarg1;
42480   arg2 = (Dali::TapGesture *)jarg2;
42481   if (!arg2) {
42482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42483     return 0;
42484   }
42485   {
42486     try {
42487       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42488     } catch (std::out_of_range& e) {
42489       {
42490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42491       };
42492     } catch (std::exception& e) {
42493       {
42494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42495       };
42496     } catch (Dali::DaliException e) {
42497       {
42498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42499       };
42500     } catch (...) {
42501       {
42502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42503       };
42504     }
42505   }
42506
42507   jresult = (void *)result;
42508   return jresult;
42509 }
42510
42511
42512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42513   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42514
42515   arg1 = (Dali::TapGesture *)jarg1;
42516   {
42517     try {
42518       delete arg1;
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42534       };
42535     }
42536   }
42537
42538 }
42539
42540
42541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42542   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42543   unsigned int arg2 ;
42544
42545   arg1 = (Dali::TapGesture *)jarg1;
42546   arg2 = (unsigned int)jarg2;
42547   if (arg1) (arg1)->numberOfTaps = arg2;
42548 }
42549
42550
42551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42552   unsigned int jresult ;
42553   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42554   unsigned int result;
42555
42556   arg1 = (Dali::TapGesture *)jarg1;
42557   result = (unsigned int) ((arg1)->numberOfTaps);
42558   jresult = result;
42559   return jresult;
42560 }
42561
42562
42563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42564   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42565   unsigned int arg2 ;
42566
42567   arg1 = (Dali::TapGesture *)jarg1;
42568   arg2 = (unsigned int)jarg2;
42569   if (arg1) (arg1)->numberOfTouches = arg2;
42570 }
42571
42572
42573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42574   unsigned int jresult ;
42575   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42576   unsigned int result;
42577
42578   arg1 = (Dali::TapGesture *)jarg1;
42579   result = (unsigned int) ((arg1)->numberOfTouches);
42580   jresult = result;
42581   return jresult;
42582 }
42583
42584
42585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42586   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42587   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42588
42589   arg1 = (Dali::TapGesture *)jarg1;
42590   arg2 = (Dali::Vector2 *)jarg2;
42591   if (arg1) (arg1)->screenPoint = *arg2;
42592 }
42593
42594
42595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42596   void * jresult ;
42597   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42598   Dali::Vector2 *result = 0 ;
42599
42600   arg1 = (Dali::TapGesture *)jarg1;
42601   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42608   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42609   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42610
42611   arg1 = (Dali::TapGesture *)jarg1;
42612   arg2 = (Dali::Vector2 *)jarg2;
42613   if (arg1) (arg1)->localPoint = *arg2;
42614 }
42615
42616
42617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42618   void * jresult ;
42619   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42620   Dali::Vector2 *result = 0 ;
42621
42622   arg1 = (Dali::TapGesture *)jarg1;
42623   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42624   jresult = (void *)result;
42625   return jresult;
42626 }
42627
42628
42629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42630   void * jresult ;
42631   Dali::AlphaFunction *result = 0 ;
42632
42633   {
42634     try {
42635       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42636     } catch (std::out_of_range& e) {
42637       {
42638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42639       };
42640     } catch (std::exception& e) {
42641       {
42642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42643       };
42644     } catch (Dali::DaliException e) {
42645       {
42646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42647       };
42648     } catch (...) {
42649       {
42650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42651       };
42652     }
42653   }
42654
42655   jresult = (void *)result;
42656   return jresult;
42657 }
42658
42659
42660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42661   void * jresult ;
42662   Dali::AlphaFunction::BuiltinFunction arg1 ;
42663   Dali::AlphaFunction *result = 0 ;
42664
42665   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42666   {
42667     try {
42668       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42669     } catch (std::out_of_range& e) {
42670       {
42671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42672       };
42673     } catch (std::exception& e) {
42674       {
42675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (Dali::DaliException e) {
42678       {
42679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42680       };
42681     } catch (...) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42684       };
42685     }
42686   }
42687
42688   jresult = (void *)result;
42689   return jresult;
42690 }
42691
42692
42693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42694   void * jresult ;
42695   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42696   Dali::AlphaFunction *result = 0 ;
42697
42698   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42699   {
42700     try {
42701       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42702     } catch (std::out_of_range& e) {
42703       {
42704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42705       };
42706     } catch (std::exception& e) {
42707       {
42708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42709       };
42710     } catch (Dali::DaliException e) {
42711       {
42712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42713       };
42714     } catch (...) {
42715       {
42716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42717       };
42718     }
42719   }
42720
42721   jresult = (void *)result;
42722   return jresult;
42723 }
42724
42725
42726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42727   void * jresult ;
42728   Dali::Vector2 *arg1 = 0 ;
42729   Dali::Vector2 *arg2 = 0 ;
42730   Dali::AlphaFunction *result = 0 ;
42731
42732   arg1 = (Dali::Vector2 *)jarg1;
42733   if (!arg1) {
42734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42735     return 0;
42736   }
42737   arg2 = (Dali::Vector2 *)jarg2;
42738   if (!arg2) {
42739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42740     return 0;
42741   }
42742   {
42743     try {
42744       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42745     } catch (std::out_of_range& e) {
42746       {
42747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42748       };
42749     } catch (std::exception& e) {
42750       {
42751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42752       };
42753     } catch (Dali::DaliException e) {
42754       {
42755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42756       };
42757     } catch (...) {
42758       {
42759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42760       };
42761     }
42762   }
42763
42764   jresult = (void *)result;
42765   return jresult;
42766 }
42767
42768
42769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42770   void * jresult ;
42771   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42772   Dali::Vector4 result;
42773
42774   arg1 = (Dali::AlphaFunction *)jarg1;
42775   {
42776     try {
42777       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42778     } catch (std::out_of_range& e) {
42779       {
42780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42781       };
42782     } catch (std::exception& e) {
42783       {
42784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42785       };
42786     } catch (Dali::DaliException e) {
42787       {
42788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42789       };
42790     } catch (...) {
42791       {
42792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42793       };
42794     }
42795   }
42796
42797   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42798   return jresult;
42799 }
42800
42801
42802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42803   void * jresult ;
42804   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42805   Dali::AlphaFunctionPrototype result;
42806
42807   arg1 = (Dali::AlphaFunction *)jarg1;
42808   {
42809     try {
42810       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42811     } catch (std::out_of_range& e) {
42812       {
42813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (std::exception& e) {
42816       {
42817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (Dali::DaliException e) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42822       };
42823     } catch (...) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42826       };
42827     }
42828   }
42829
42830   jresult = (void *)result;
42831   return jresult;
42832 }
42833
42834
42835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42836   int jresult ;
42837   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42838   Dali::AlphaFunction::BuiltinFunction result;
42839
42840   arg1 = (Dali::AlphaFunction *)jarg1;
42841   {
42842     try {
42843       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42844     } catch (std::out_of_range& e) {
42845       {
42846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (std::exception& e) {
42849       {
42850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (Dali::DaliException e) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862
42863   jresult = (int)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42869   int jresult ;
42870   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42871   Dali::AlphaFunction::Mode result;
42872
42873   arg1 = (Dali::AlphaFunction *)jarg1;
42874   {
42875     try {
42876       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42877     } catch (std::out_of_range& e) {
42878       {
42879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (std::exception& e) {
42882       {
42883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (Dali::DaliException e) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895
42896   jresult = (int)result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42902   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42903
42904   arg1 = (Dali::AlphaFunction *)jarg1;
42905   {
42906     try {
42907       delete arg1;
42908     } catch (std::out_of_range& e) {
42909       {
42910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42911       };
42912     } catch (std::exception& e) {
42913       {
42914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42915       };
42916     } catch (Dali::DaliException e) {
42917       {
42918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42919       };
42920     } catch (...) {
42921       {
42922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42923       };
42924     }
42925   }
42926
42927 }
42928
42929
42930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42931   void * jresult ;
42932   Dali::KeyFrames result;
42933
42934   {
42935     try {
42936       result = Dali::KeyFrames::New();
42937     } catch (std::out_of_range& e) {
42938       {
42939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42940       };
42941     } catch (std::exception& e) {
42942       {
42943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42944       };
42945     } catch (Dali::DaliException e) {
42946       {
42947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42948       };
42949     } catch (...) {
42950       {
42951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42952       };
42953     }
42954   }
42955
42956   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42957   return jresult;
42958 }
42959
42960
42961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42962   void * jresult ;
42963   Dali::BaseHandle arg1 ;
42964   Dali::BaseHandle *argp1 ;
42965   Dali::KeyFrames result;
42966
42967   argp1 = (Dali::BaseHandle *)jarg1;
42968   if (!argp1) {
42969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42970     return 0;
42971   }
42972   arg1 = *argp1;
42973   {
42974     try {
42975       result = Dali::KeyFrames::DownCast(arg1);
42976     } catch (std::out_of_range& e) {
42977       {
42978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (std::exception& e) {
42981       {
42982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (Dali::DaliException e) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42987       };
42988     } catch (...) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42991       };
42992     }
42993   }
42994
42995   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42996   return jresult;
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43001   void * jresult ;
43002   Dali::KeyFrames *result = 0 ;
43003
43004   {
43005     try {
43006       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43007     } catch (std::out_of_range& e) {
43008       {
43009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43010       };
43011     } catch (std::exception& e) {
43012       {
43013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43014       };
43015     } catch (Dali::DaliException e) {
43016       {
43017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43018       };
43019     } catch (...) {
43020       {
43021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43022       };
43023     }
43024   }
43025
43026   jresult = (void *)result;
43027   return jresult;
43028 }
43029
43030
43031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43032   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43033
43034   arg1 = (Dali::KeyFrames *)jarg1;
43035   {
43036     try {
43037       delete arg1;
43038     } catch (std::out_of_range& e) {
43039       {
43040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43041       };
43042     } catch (std::exception& e) {
43043       {
43044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43045       };
43046     } catch (Dali::DaliException e) {
43047       {
43048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43049       };
43050     } catch (...) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43053       };
43054     }
43055   }
43056
43057 }
43058
43059
43060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43061   void * jresult ;
43062   Dali::KeyFrames *arg1 = 0 ;
43063   Dali::KeyFrames *result = 0 ;
43064
43065   arg1 = (Dali::KeyFrames *)jarg1;
43066   if (!arg1) {
43067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43068     return 0;
43069   }
43070   {
43071     try {
43072       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43073     } catch (std::out_of_range& e) {
43074       {
43075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43076       };
43077     } catch (std::exception& e) {
43078       {
43079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43080       };
43081     } catch (Dali::DaliException e) {
43082       {
43083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43084       };
43085     } catch (...) {
43086       {
43087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43088       };
43089     }
43090   }
43091
43092   jresult = (void *)result;
43093   return jresult;
43094 }
43095
43096
43097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43098   void * jresult ;
43099   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43100   Dali::KeyFrames *arg2 = 0 ;
43101   Dali::KeyFrames *result = 0 ;
43102
43103   arg1 = (Dali::KeyFrames *)jarg1;
43104   arg2 = (Dali::KeyFrames *)jarg2;
43105   if (!arg2) {
43106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43107     return 0;
43108   }
43109   {
43110     try {
43111       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43112     } catch (std::out_of_range& e) {
43113       {
43114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (std::exception& e) {
43117       {
43118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (Dali::DaliException e) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43123       };
43124     } catch (...) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43127       };
43128     }
43129   }
43130
43131   jresult = (void *)result;
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43137   int jresult ;
43138   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43139   Dali::Property::Type result;
43140
43141   arg1 = (Dali::KeyFrames *)jarg1;
43142   {
43143     try {
43144       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (Dali::DaliException e) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43156       };
43157     } catch (...) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43160       };
43161     }
43162   }
43163
43164   jresult = (int)result;
43165   return jresult;
43166 }
43167
43168
43169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43170   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43171   float arg2 ;
43172   Dali::Property::Value arg3 ;
43173   Dali::Property::Value *argp3 ;
43174
43175   arg1 = (Dali::KeyFrames *)jarg1;
43176   arg2 = (float)jarg2;
43177   argp3 = (Dali::Property::Value *)jarg3;
43178   if (!argp3) {
43179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43180     return ;
43181   }
43182   arg3 = *argp3;
43183   {
43184     try {
43185       (arg1)->Add(arg2,arg3);
43186     } catch (std::out_of_range& e) {
43187       {
43188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43189       };
43190     } catch (std::exception& e) {
43191       {
43192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43193       };
43194     } catch (Dali::DaliException e) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43201       };
43202     }
43203   }
43204
43205 }
43206
43207
43208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43209   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43210   float arg2 ;
43211   Dali::Property::Value arg3 ;
43212   Dali::AlphaFunction arg4 ;
43213   Dali::Property::Value *argp3 ;
43214   Dali::AlphaFunction *argp4 ;
43215
43216   arg1 = (Dali::KeyFrames *)jarg1;
43217   arg2 = (float)jarg2;
43218   argp3 = (Dali::Property::Value *)jarg3;
43219   if (!argp3) {
43220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43221     return ;
43222   }
43223   arg3 = *argp3;
43224   argp4 = (Dali::AlphaFunction *)jarg4;
43225   if (!argp4) {
43226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43227     return ;
43228   }
43229   arg4 = *argp4;
43230   {
43231     try {
43232       (arg1)->Add(arg2,arg3,arg4);
43233     } catch (std::out_of_range& e) {
43234       {
43235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43236       };
43237     } catch (std::exception& e) {
43238       {
43239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43240       };
43241     } catch (Dali::DaliException e) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43244       };
43245     } catch (...) {
43246       {
43247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43248       };
43249     }
43250   }
43251
43252 }
43253
43254
43255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43256   int jresult ;
43257   int result;
43258
43259   result = (int)Dali::Path::Property::POINTS;
43260   jresult = (int)result;
43261   return jresult;
43262 }
43263
43264
43265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43266   int jresult ;
43267   int result;
43268
43269   result = (int)Dali::Path::Property::CONTROL_POINTS;
43270   jresult = (int)result;
43271   return jresult;
43272 }
43273
43274
43275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43276   void * jresult ;
43277   Dali::Path::Property *result = 0 ;
43278
43279   {
43280     try {
43281       result = (Dali::Path::Property *)new Dali::Path::Property();
43282     } catch (std::out_of_range& e) {
43283       {
43284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43285       };
43286     } catch (std::exception& e) {
43287       {
43288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43289       };
43290     } catch (Dali::DaliException e) {
43291       {
43292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43293       };
43294     } catch (...) {
43295       {
43296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43297       };
43298     }
43299   }
43300
43301   jresult = (void *)result;
43302   return jresult;
43303 }
43304
43305
43306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43307   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43308
43309   arg1 = (Dali::Path::Property *)jarg1;
43310   {
43311     try {
43312       delete arg1;
43313     } catch (std::out_of_range& e) {
43314       {
43315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43316       };
43317     } catch (std::exception& e) {
43318       {
43319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43320       };
43321     } catch (Dali::DaliException e) {
43322       {
43323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43328       };
43329     }
43330   }
43331
43332 }
43333
43334
43335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43336   void * jresult ;
43337   Dali::Path result;
43338
43339   {
43340     try {
43341       result = Dali::Path::New();
43342     } catch (std::out_of_range& e) {
43343       {
43344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43345       };
43346     } catch (std::exception& e) {
43347       {
43348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43349       };
43350     } catch (Dali::DaliException e) {
43351       {
43352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43353       };
43354     } catch (...) {
43355       {
43356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43357       };
43358     }
43359   }
43360
43361   jresult = new Dali::Path((const Dali::Path &)result);
43362   return jresult;
43363 }
43364
43365
43366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43367   void * jresult ;
43368   Dali::BaseHandle arg1 ;
43369   Dali::BaseHandle *argp1 ;
43370   Dali::Path result;
43371
43372   argp1 = (Dali::BaseHandle *)jarg1;
43373   if (!argp1) {
43374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43375     return 0;
43376   }
43377   arg1 = *argp1;
43378   {
43379     try {
43380       result = Dali::Path::DownCast(arg1);
43381     } catch (std::out_of_range& e) {
43382       {
43383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43384       };
43385     } catch (std::exception& e) {
43386       {
43387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43388       };
43389     } catch (Dali::DaliException e) {
43390       {
43391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43392       };
43393     } catch (...) {
43394       {
43395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43396       };
43397     }
43398   }
43399
43400   jresult = new Dali::Path((const Dali::Path &)result);
43401   return jresult;
43402 }
43403
43404
43405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43406   void * jresult ;
43407   Dali::Path *result = 0 ;
43408
43409   {
43410     try {
43411       result = (Dali::Path *)new Dali::Path();
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (void *)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43437   Dali::Path *arg1 = (Dali::Path *) 0 ;
43438
43439   arg1 = (Dali::Path *)jarg1;
43440   {
43441     try {
43442       delete arg1;
43443     } catch (std::out_of_range& e) {
43444       {
43445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43446       };
43447     } catch (std::exception& e) {
43448       {
43449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43450       };
43451     } catch (Dali::DaliException e) {
43452       {
43453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43454       };
43455     } catch (...) {
43456       {
43457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43458       };
43459     }
43460   }
43461
43462 }
43463
43464
43465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43466   void * jresult ;
43467   Dali::Path *arg1 = 0 ;
43468   Dali::Path *result = 0 ;
43469
43470   arg1 = (Dali::Path *)jarg1;
43471   if (!arg1) {
43472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43473     return 0;
43474   }
43475   {
43476     try {
43477       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43478     } catch (std::out_of_range& e) {
43479       {
43480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43481       };
43482     } catch (std::exception& e) {
43483       {
43484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43485       };
43486     } catch (Dali::DaliException e) {
43487       {
43488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43489       };
43490     } catch (...) {
43491       {
43492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43493       };
43494     }
43495   }
43496
43497   jresult = (void *)result;
43498   return jresult;
43499 }
43500
43501
43502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43503   void * jresult ;
43504   Dali::Path *arg1 = (Dali::Path *) 0 ;
43505   Dali::Path *arg2 = 0 ;
43506   Dali::Path *result = 0 ;
43507
43508   arg1 = (Dali::Path *)jarg1;
43509   arg2 = (Dali::Path *)jarg2;
43510   if (!arg2) {
43511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43512     return 0;
43513   }
43514   {
43515     try {
43516       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43517     } catch (std::out_of_range& e) {
43518       {
43519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (std::exception& e) {
43522       {
43523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (Dali::DaliException e) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43528       };
43529     } catch (...) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43532       };
43533     }
43534   }
43535
43536   jresult = (void *)result;
43537   return jresult;
43538 }
43539
43540
43541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43542   Dali::Path *arg1 = (Dali::Path *) 0 ;
43543   Dali::Vector3 *arg2 = 0 ;
43544
43545   arg1 = (Dali::Path *)jarg1;
43546   arg2 = (Dali::Vector3 *)jarg2;
43547   if (!arg2) {
43548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43549     return ;
43550   }
43551   {
43552     try {
43553       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43554     } catch (std::out_of_range& e) {
43555       {
43556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43557       };
43558     } catch (std::exception& e) {
43559       {
43560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43561       };
43562     } catch (Dali::DaliException e) {
43563       {
43564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43565       };
43566     } catch (...) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43569       };
43570     }
43571   }
43572
43573 }
43574
43575
43576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43577   Dali::Path *arg1 = (Dali::Path *) 0 ;
43578   Dali::Vector3 *arg2 = 0 ;
43579
43580   arg1 = (Dali::Path *)jarg1;
43581   arg2 = (Dali::Vector3 *)jarg2;
43582   if (!arg2) {
43583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43584     return ;
43585   }
43586   {
43587     try {
43588       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43589     } catch (std::out_of_range& e) {
43590       {
43591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43592       };
43593     } catch (std::exception& e) {
43594       {
43595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43596       };
43597     } catch (Dali::DaliException e) {
43598       {
43599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43604       };
43605     }
43606   }
43607
43608 }
43609
43610
43611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43612   Dali::Path *arg1 = (Dali::Path *) 0 ;
43613   float arg2 ;
43614
43615   arg1 = (Dali::Path *)jarg1;
43616   arg2 = (float)jarg2;
43617   {
43618     try {
43619       (arg1)->GenerateControlPoints(arg2);
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43627       };
43628     } catch (Dali::DaliException e) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43635       };
43636     }
43637   }
43638
43639 }
43640
43641
43642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43643   Dali::Path *arg1 = (Dali::Path *) 0 ;
43644   float arg2 ;
43645   Dali::Vector3 *arg3 = 0 ;
43646   Dali::Vector3 *arg4 = 0 ;
43647
43648   arg1 = (Dali::Path *)jarg1;
43649   arg2 = (float)jarg2;
43650   arg3 = (Dali::Vector3 *)jarg3;
43651   if (!arg3) {
43652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43653     return ;
43654   }
43655   arg4 = (Dali::Vector3 *)jarg4;
43656   if (!arg4) {
43657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43658     return ;
43659   }
43660   {
43661     try {
43662       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43663     } catch (std::out_of_range& e) {
43664       {
43665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43666       };
43667     } catch (std::exception& e) {
43668       {
43669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43670       };
43671     } catch (Dali::DaliException e) {
43672       {
43673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43674       };
43675     } catch (...) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43678       };
43679     }
43680   }
43681
43682 }
43683
43684
43685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43686   void * jresult ;
43687   Dali::Path *arg1 = (Dali::Path *) 0 ;
43688   size_t arg2 ;
43689   Dali::Vector3 *result = 0 ;
43690
43691   arg1 = (Dali::Path *)jarg1;
43692   arg2 = (size_t)jarg2;
43693   {
43694     try {
43695       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43696     } catch (std::out_of_range& e) {
43697       {
43698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (std::exception& e) {
43701       {
43702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (Dali::DaliException e) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714
43715   jresult = (void *)result;
43716   return jresult;
43717 }
43718
43719
43720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43721   void * jresult ;
43722   Dali::Path *arg1 = (Dali::Path *) 0 ;
43723   size_t arg2 ;
43724   Dali::Vector3 *result = 0 ;
43725
43726   arg1 = (Dali::Path *)jarg1;
43727   arg2 = (size_t)jarg2;
43728   {
43729     try {
43730       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43731     } catch (std::out_of_range& e) {
43732       {
43733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43734       };
43735     } catch (std::exception& e) {
43736       {
43737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43738       };
43739     } catch (Dali::DaliException e) {
43740       {
43741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43742       };
43743     } catch (...) {
43744       {
43745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43746       };
43747     }
43748   }
43749
43750   jresult = (void *)result;
43751   return jresult;
43752 }
43753
43754
43755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43756   unsigned long jresult ;
43757   Dali::Path *arg1 = (Dali::Path *) 0 ;
43758   size_t result;
43759
43760   arg1 = (Dali::Path *)jarg1;
43761   {
43762     try {
43763       result = ((Dali::Path const *)arg1)->GetPointCount();
43764     } catch (std::out_of_range& e) {
43765       {
43766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43767       };
43768     } catch (std::exception& e) {
43769       {
43770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43771       };
43772     } catch (Dali::DaliException e) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43775       };
43776     } catch (...) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43779       };
43780     }
43781   }
43782
43783   jresult = (unsigned long)result;
43784   return jresult;
43785 }
43786
43787
43788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43789   void * jresult ;
43790   float arg1 ;
43791   Dali::TimePeriod *result = 0 ;
43792
43793   arg1 = (float)jarg1;
43794   {
43795     try {
43796       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43797     } catch (std::out_of_range& e) {
43798       {
43799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43800       };
43801     } catch (std::exception& e) {
43802       {
43803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43804       };
43805     } catch (Dali::DaliException e) {
43806       {
43807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43808       };
43809     } catch (...) {
43810       {
43811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43812       };
43813     }
43814   }
43815
43816   jresult = (void *)result;
43817   return jresult;
43818 }
43819
43820
43821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43822   void * jresult ;
43823   float arg1 ;
43824   float arg2 ;
43825   Dali::TimePeriod *result = 0 ;
43826
43827   arg1 = (float)jarg1;
43828   arg2 = (float)jarg2;
43829   {
43830     try {
43831       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43832     } catch (std::out_of_range& e) {
43833       {
43834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43835       };
43836     } catch (std::exception& e) {
43837       {
43838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43839       };
43840     } catch (Dali::DaliException e) {
43841       {
43842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43843       };
43844     } catch (...) {
43845       {
43846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43847       };
43848     }
43849   }
43850
43851   jresult = (void *)result;
43852   return jresult;
43853 }
43854
43855
43856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43857   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43858
43859   arg1 = (Dali::TimePeriod *)jarg1;
43860   {
43861     try {
43862       delete arg1;
43863     } catch (std::out_of_range& e) {
43864       {
43865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43866       };
43867     } catch (std::exception& e) {
43868       {
43869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43870       };
43871     } catch (Dali::DaliException e) {
43872       {
43873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43874       };
43875     } catch (...) {
43876       {
43877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43878       };
43879     }
43880   }
43881
43882 }
43883
43884
43885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43886   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43887   float arg2 ;
43888
43889   arg1 = (Dali::TimePeriod *)jarg1;
43890   arg2 = (float)jarg2;
43891   if (arg1) (arg1)->delaySeconds = arg2;
43892 }
43893
43894
43895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43896   float jresult ;
43897   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43898   float result;
43899
43900   arg1 = (Dali::TimePeriod *)jarg1;
43901   result = (float) ((arg1)->delaySeconds);
43902   jresult = result;
43903   return jresult;
43904 }
43905
43906
43907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43908   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43909   float arg2 ;
43910
43911   arg1 = (Dali::TimePeriod *)jarg1;
43912   arg2 = (float)jarg2;
43913   if (arg1) (arg1)->durationSeconds = arg2;
43914 }
43915
43916
43917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43918   float jresult ;
43919   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43920   float result;
43921
43922   arg1 = (Dali::TimePeriod *)jarg1;
43923   result = (float) ((arg1)->durationSeconds);
43924   jresult = result;
43925   return jresult;
43926 }
43927
43928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43929   int jresult ;
43930   int result;
43931
43932   result = (int)Dali::LinearConstrainer::Property::VALUE;
43933   jresult = (int)result;
43934   return jresult;
43935 }
43936
43937
43938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43939   int jresult ;
43940   int result;
43941
43942   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43943   jresult = (int)result;
43944   return jresult;
43945 }
43946
43947
43948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43949   void * jresult ;
43950   Dali::LinearConstrainer::Property *result = 0 ;
43951
43952   {
43953     try {
43954       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43955     } catch (std::out_of_range& e) {
43956       {
43957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43958       };
43959     } catch (std::exception& e) {
43960       {
43961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43962       };
43963     } catch (Dali::DaliException e) {
43964       {
43965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43966       };
43967     } catch (...) {
43968       {
43969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43970       };
43971     }
43972   }
43973
43974   jresult = (void *)result;
43975   return jresult;
43976 }
43977
43978
43979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43980   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43981
43982   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43983   {
43984     try {
43985       delete arg1;
43986     } catch (std::out_of_range& e) {
43987       {
43988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43989       };
43990     } catch (std::exception& e) {
43991       {
43992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43993       };
43994     } catch (Dali::DaliException e) {
43995       {
43996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43997       };
43998     } catch (...) {
43999       {
44000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44001       };
44002     }
44003   }
44004
44005 }
44006
44007
44008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44009   void * jresult ;
44010   Dali::LinearConstrainer result;
44011
44012   {
44013     try {
44014       result = Dali::LinearConstrainer::New();
44015     } catch (std::out_of_range& e) {
44016       {
44017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44018       };
44019     } catch (std::exception& e) {
44020       {
44021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (Dali::DaliException e) {
44024       {
44025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033
44034   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44035   return jresult;
44036 }
44037
44038
44039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44040   void * jresult ;
44041   Dali::BaseHandle arg1 ;
44042   Dali::BaseHandle *argp1 ;
44043   Dali::LinearConstrainer result;
44044
44045   argp1 = (Dali::BaseHandle *)jarg1;
44046   if (!argp1) {
44047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44048     return 0;
44049   }
44050   arg1 = *argp1;
44051   {
44052     try {
44053       result = Dali::LinearConstrainer::DownCast(arg1);
44054     } catch (std::out_of_range& e) {
44055       {
44056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44057       };
44058     } catch (std::exception& e) {
44059       {
44060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (Dali::DaliException e) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44065       };
44066     } catch (...) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44069       };
44070     }
44071   }
44072
44073   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44079   void * jresult ;
44080   Dali::LinearConstrainer *result = 0 ;
44081
44082   {
44083     try {
44084       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44085     } catch (std::out_of_range& e) {
44086       {
44087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44088       };
44089     } catch (std::exception& e) {
44090       {
44091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44092       };
44093     } catch (Dali::DaliException e) {
44094       {
44095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44096       };
44097     } catch (...) {
44098       {
44099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44100       };
44101     }
44102   }
44103
44104   jresult = (void *)result;
44105   return jresult;
44106 }
44107
44108
44109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44110   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44111
44112   arg1 = (Dali::LinearConstrainer *)jarg1;
44113   {
44114     try {
44115       delete arg1;
44116     } catch (std::out_of_range& e) {
44117       {
44118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44119       };
44120     } catch (std::exception& e) {
44121       {
44122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44123       };
44124     } catch (Dali::DaliException e) {
44125       {
44126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44127       };
44128     } catch (...) {
44129       {
44130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44131       };
44132     }
44133   }
44134
44135 }
44136
44137
44138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44139   void * jresult ;
44140   Dali::LinearConstrainer *arg1 = 0 ;
44141   Dali::LinearConstrainer *result = 0 ;
44142
44143   arg1 = (Dali::LinearConstrainer *)jarg1;
44144   if (!arg1) {
44145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44146     return 0;
44147   }
44148   {
44149     try {
44150       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44151     } catch (std::out_of_range& e) {
44152       {
44153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44154       };
44155     } catch (std::exception& e) {
44156       {
44157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (Dali::DaliException e) {
44160       {
44161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169
44170   jresult = (void *)result;
44171   return jresult;
44172 }
44173
44174
44175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44176   void * jresult ;
44177   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44178   Dali::LinearConstrainer *arg2 = 0 ;
44179   Dali::LinearConstrainer *result = 0 ;
44180
44181   arg1 = (Dali::LinearConstrainer *)jarg1;
44182   arg2 = (Dali::LinearConstrainer *)jarg2;
44183   if (!arg2) {
44184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44185     return 0;
44186   }
44187   {
44188     try {
44189       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44190     } catch (std::out_of_range& e) {
44191       {
44192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (std::exception& e) {
44195       {
44196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (Dali::DaliException e) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44201       };
44202     } catch (...) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44205       };
44206     }
44207   }
44208
44209   jresult = (void *)result;
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44215   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44216   SwigValueWrapper< Dali::Property > arg2 ;
44217   SwigValueWrapper< Dali::Property > arg3 ;
44218   Dali::Vector2 *arg4 = 0 ;
44219   Dali::Vector2 *arg5 = 0 ;
44220   Dali::Property *argp2 ;
44221   Dali::Property *argp3 ;
44222
44223   arg1 = (Dali::LinearConstrainer *)jarg1;
44224   argp2 = (Dali::Property *)jarg2;
44225   if (!argp2) {
44226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44227     return ;
44228   }
44229   arg2 = *argp2;
44230   argp3 = (Dali::Property *)jarg3;
44231   if (!argp3) {
44232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44233     return ;
44234   }
44235   arg3 = *argp3;
44236   arg4 = (Dali::Vector2 *)jarg4;
44237   if (!arg4) {
44238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44239     return ;
44240   }
44241   arg5 = (Dali::Vector2 *)jarg5;
44242   if (!arg5) {
44243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44244     return ;
44245   }
44246   {
44247     try {
44248       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44249     } catch (std::out_of_range& e) {
44250       {
44251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44252       };
44253     } catch (std::exception& e) {
44254       {
44255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (Dali::DaliException e) {
44258       {
44259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44260       };
44261     } catch (...) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44264       };
44265     }
44266   }
44267
44268 }
44269
44270
44271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44272   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44273   SwigValueWrapper< Dali::Property > arg2 ;
44274   SwigValueWrapper< Dali::Property > arg3 ;
44275   Dali::Vector2 *arg4 = 0 ;
44276   Dali::Property *argp2 ;
44277   Dali::Property *argp3 ;
44278
44279   arg1 = (Dali::LinearConstrainer *)jarg1;
44280   argp2 = (Dali::Property *)jarg2;
44281   if (!argp2) {
44282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44283     return ;
44284   }
44285   arg2 = *argp2;
44286   argp3 = (Dali::Property *)jarg3;
44287   if (!argp3) {
44288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44289     return ;
44290   }
44291   arg3 = *argp3;
44292   arg4 = (Dali::Vector2 *)jarg4;
44293   if (!arg4) {
44294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44295     return ;
44296   }
44297   {
44298     try {
44299       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44300     } catch (std::out_of_range& e) {
44301       {
44302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44303       };
44304     } catch (std::exception& e) {
44305       {
44306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44307       };
44308     } catch (Dali::DaliException e) {
44309       {
44310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44311       };
44312     } catch (...) {
44313       {
44314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44315       };
44316     }
44317   }
44318
44319 }
44320
44321
44322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44323   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44324   Dali::Handle *arg2 = 0 ;
44325
44326   arg1 = (Dali::LinearConstrainer *)jarg1;
44327   arg2 = (Dali::Handle *)jarg2;
44328   if (!arg2) {
44329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44330     return ;
44331   }
44332   {
44333     try {
44334       (arg1)->Remove(*arg2);
44335     } catch (std::out_of_range& e) {
44336       {
44337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44338       };
44339     } catch (std::exception& e) {
44340       {
44341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44342       };
44343     } catch (Dali::DaliException e) {
44344       {
44345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44346       };
44347     } catch (...) {
44348       {
44349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44350       };
44351     }
44352   }
44353
44354 }
44355
44356
44357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44358   int jresult ;
44359   int result;
44360
44361   result = (int)Dali::PathConstrainer::Property::FORWARD;
44362   jresult = (int)result;
44363   return jresult;
44364 }
44365
44366
44367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44368   int jresult ;
44369   int result;
44370
44371   result = (int)Dali::PathConstrainer::Property::POINTS;
44372   jresult = (int)result;
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44378   int jresult ;
44379   int result;
44380
44381   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44382   jresult = (int)result;
44383   return jresult;
44384 }
44385
44386
44387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44388   void * jresult ;
44389   Dali::PathConstrainer::Property *result = 0 ;
44390
44391   {
44392     try {
44393       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44394     } catch (std::out_of_range& e) {
44395       {
44396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (std::exception& e) {
44399       {
44400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44401       };
44402     } catch (Dali::DaliException e) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44405       };
44406     } catch (...) {
44407       {
44408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44409       };
44410     }
44411   }
44412
44413   jresult = (void *)result;
44414   return jresult;
44415 }
44416
44417
44418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44419   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44420
44421   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44422   {
44423     try {
44424       delete arg1;
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44432       };
44433     } catch (Dali::DaliException e) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44436       };
44437     } catch (...) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44440       };
44441     }
44442   }
44443
44444 }
44445
44446
44447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44448   void * jresult ;
44449   Dali::PathConstrainer result;
44450
44451   {
44452     try {
44453       result = Dali::PathConstrainer::New();
44454     } catch (std::out_of_range& e) {
44455       {
44456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44457       };
44458     } catch (std::exception& e) {
44459       {
44460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44461       };
44462     } catch (Dali::DaliException e) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44465       };
44466     } catch (...) {
44467       {
44468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44469       };
44470     }
44471   }
44472
44473   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44474   return jresult;
44475 }
44476
44477
44478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44479   void * jresult ;
44480   Dali::BaseHandle arg1 ;
44481   Dali::BaseHandle *argp1 ;
44482   Dali::PathConstrainer result;
44483
44484   argp1 = (Dali::BaseHandle *)jarg1;
44485   if (!argp1) {
44486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44487     return 0;
44488   }
44489   arg1 = *argp1;
44490   {
44491     try {
44492       result = Dali::PathConstrainer::DownCast(arg1);
44493     } catch (std::out_of_range& e) {
44494       {
44495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44496       };
44497     } catch (std::exception& e) {
44498       {
44499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44500       };
44501     } catch (Dali::DaliException e) {
44502       {
44503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44504       };
44505     } catch (...) {
44506       {
44507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44508       };
44509     }
44510   }
44511
44512   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44513   return jresult;
44514 }
44515
44516
44517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44518   void * jresult ;
44519   Dali::PathConstrainer *result = 0 ;
44520
44521   {
44522     try {
44523       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44524     } catch (std::out_of_range& e) {
44525       {
44526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44527       };
44528     } catch (std::exception& e) {
44529       {
44530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44531       };
44532     } catch (Dali::DaliException e) {
44533       {
44534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44535       };
44536     } catch (...) {
44537       {
44538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44539       };
44540     }
44541   }
44542
44543   jresult = (void *)result;
44544   return jresult;
44545 }
44546
44547
44548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44549   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44550
44551   arg1 = (Dali::PathConstrainer *)jarg1;
44552   {
44553     try {
44554       delete arg1;
44555     } catch (std::out_of_range& e) {
44556       {
44557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44558       };
44559     } catch (std::exception& e) {
44560       {
44561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44562       };
44563     } catch (Dali::DaliException e) {
44564       {
44565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44566       };
44567     } catch (...) {
44568       {
44569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44570       };
44571     }
44572   }
44573
44574 }
44575
44576
44577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44578   void * jresult ;
44579   Dali::PathConstrainer *arg1 = 0 ;
44580   Dali::PathConstrainer *result = 0 ;
44581
44582   arg1 = (Dali::PathConstrainer *)jarg1;
44583   if (!arg1) {
44584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44585     return 0;
44586   }
44587   {
44588     try {
44589       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44590     } catch (std::out_of_range& e) {
44591       {
44592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44593       };
44594     } catch (std::exception& e) {
44595       {
44596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44597       };
44598     } catch (Dali::DaliException e) {
44599       {
44600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44601       };
44602     } catch (...) {
44603       {
44604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44605       };
44606     }
44607   }
44608
44609   jresult = (void *)result;
44610   return jresult;
44611 }
44612
44613
44614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44615   void * jresult ;
44616   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44617   Dali::PathConstrainer *arg2 = 0 ;
44618   Dali::PathConstrainer *result = 0 ;
44619
44620   arg1 = (Dali::PathConstrainer *)jarg1;
44621   arg2 = (Dali::PathConstrainer *)jarg2;
44622   if (!arg2) {
44623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44624     return 0;
44625   }
44626   {
44627     try {
44628       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44629     } catch (std::out_of_range& e) {
44630       {
44631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (std::exception& e) {
44634       {
44635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (Dali::DaliException e) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44644       };
44645     }
44646   }
44647
44648   jresult = (void *)result;
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44654   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44655   SwigValueWrapper< Dali::Property > arg2 ;
44656   SwigValueWrapper< Dali::Property > arg3 ;
44657   Dali::Vector2 *arg4 = 0 ;
44658   Dali::Vector2 *arg5 = 0 ;
44659   Dali::Property *argp2 ;
44660   Dali::Property *argp3 ;
44661
44662   arg1 = (Dali::PathConstrainer *)jarg1;
44663   argp2 = (Dali::Property *)jarg2;
44664   if (!argp2) {
44665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44666     return ;
44667   }
44668   arg2 = *argp2;
44669   argp3 = (Dali::Property *)jarg3;
44670   if (!argp3) {
44671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44672     return ;
44673   }
44674   arg3 = *argp3;
44675   arg4 = (Dali::Vector2 *)jarg4;
44676   if (!arg4) {
44677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44678     return ;
44679   }
44680   arg5 = (Dali::Vector2 *)jarg5;
44681   if (!arg5) {
44682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44683     return ;
44684   }
44685   {
44686     try {
44687       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44688     } catch (std::out_of_range& e) {
44689       {
44690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44691       };
44692     } catch (std::exception& e) {
44693       {
44694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (Dali::DaliException e) {
44697       {
44698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44699       };
44700     } catch (...) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44703       };
44704     }
44705   }
44706
44707 }
44708
44709
44710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44711   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44712   SwigValueWrapper< Dali::Property > arg2 ;
44713   SwigValueWrapper< Dali::Property > arg3 ;
44714   Dali::Vector2 *arg4 = 0 ;
44715   Dali::Property *argp2 ;
44716   Dali::Property *argp3 ;
44717
44718   arg1 = (Dali::PathConstrainer *)jarg1;
44719   argp2 = (Dali::Property *)jarg2;
44720   if (!argp2) {
44721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44722     return ;
44723   }
44724   arg2 = *argp2;
44725   argp3 = (Dali::Property *)jarg3;
44726   if (!argp3) {
44727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44728     return ;
44729   }
44730   arg3 = *argp3;
44731   arg4 = (Dali::Vector2 *)jarg4;
44732   if (!arg4) {
44733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44734     return ;
44735   }
44736   {
44737     try {
44738       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44739     } catch (std::out_of_range& e) {
44740       {
44741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44742       };
44743     } catch (std::exception& e) {
44744       {
44745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44746       };
44747     } catch (Dali::DaliException e) {
44748       {
44749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44750       };
44751     } catch (...) {
44752       {
44753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44754       };
44755     }
44756   }
44757
44758 }
44759
44760
44761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44762   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44763   Dali::Handle *arg2 = 0 ;
44764
44765   arg1 = (Dali::PathConstrainer *)jarg1;
44766   arg2 = (Dali::Handle *)jarg2;
44767   if (!arg2) {
44768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44769     return ;
44770   }
44771   {
44772     try {
44773       (arg1)->Remove(*arg2);
44774     } catch (std::out_of_range& e) {
44775       {
44776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44777       };
44778     } catch (std::exception& e) {
44779       {
44780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44781       };
44782     } catch (Dali::DaliException e) {
44783       {
44784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44785       };
44786     } catch (...) {
44787       {
44788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44789       };
44790     }
44791   }
44792
44793 }
44794
44795
44796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44797   int jresult ;
44798   Dali::FittingMode::Type result;
44799
44800   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44801   jresult = (int)result;
44802   return jresult;
44803 }
44804
44805
44806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44807   int jresult ;
44808   Dali::SamplingMode::Type result;
44809
44810   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44811   jresult = (int)result;
44812   return jresult;
44813 }
44814
44815
44816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44817   void * jresult ;
44818   Dali::BufferImage *result = 0 ;
44819
44820   {
44821     try {
44822       result = (Dali::BufferImage *)new Dali::BufferImage();
44823     } catch (std::out_of_range& e) {
44824       {
44825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44826       };
44827     } catch (std::exception& e) {
44828       {
44829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44830       };
44831     } catch (Dali::DaliException e) {
44832       {
44833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44834       };
44835     } catch (...) {
44836       {
44837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44838       };
44839     }
44840   }
44841
44842   jresult = (void *)result;
44843   return jresult;
44844 }
44845
44846
44847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
44848   void * jresult ;
44849   unsigned int arg1 ;
44850   unsigned int arg2 ;
44851   Dali::Pixel::Format arg3 ;
44852   Dali::BufferImage result;
44853
44854   arg1 = (unsigned int)jarg1;
44855   arg2 = (unsigned int)jarg2;
44856   arg3 = (Dali::Pixel::Format)jarg3;
44857   {
44858     try {
44859       result = Dali::BufferImage::New(arg1,arg2,arg3);
44860     } catch (std::out_of_range& e) {
44861       {
44862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44863       };
44864     } catch (std::exception& e) {
44865       {
44866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44867       };
44868     } catch (Dali::DaliException e) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44871       };
44872     } catch (...) {
44873       {
44874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44875       };
44876     }
44877   }
44878
44879   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44880   return jresult;
44881 }
44882
44883
44884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
44885   void * jresult ;
44886   unsigned int arg1 ;
44887   unsigned int arg2 ;
44888   Dali::BufferImage result;
44889
44890   arg1 = (unsigned int)jarg1;
44891   arg2 = (unsigned int)jarg2;
44892   {
44893     try {
44894       result = Dali::BufferImage::New(arg1,arg2);
44895     } catch (std::out_of_range& e) {
44896       {
44897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44898       };
44899     } catch (std::exception& e) {
44900       {
44901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44902       };
44903     } catch (Dali::DaliException e) {
44904       {
44905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44906       };
44907     } catch (...) {
44908       {
44909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44910       };
44911     }
44912   }
44913
44914   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44915   return jresult;
44916 }
44917
44918
44919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
44920   void * jresult ;
44921   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44922   unsigned int arg2 ;
44923   unsigned int arg3 ;
44924   Dali::Pixel::Format arg4 ;
44925   unsigned int arg5 ;
44926   Dali::BufferImage result;
44927
44928   arg1 = jarg1;
44929   arg2 = (unsigned int)jarg2;
44930   arg3 = (unsigned int)jarg3;
44931   arg4 = (Dali::Pixel::Format)jarg4;
44932   arg5 = (unsigned int)jarg5;
44933   {
44934     try {
44935       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
44936     } catch (std::out_of_range& e) {
44937       {
44938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44939       };
44940     } catch (std::exception& e) {
44941       {
44942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44943       };
44944     } catch (Dali::DaliException e) {
44945       {
44946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44947       };
44948     } catch (...) {
44949       {
44950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44951       };
44952     }
44953   }
44954
44955   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44956
44957
44958   return jresult;
44959 }
44960
44961
44962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
44963   void * jresult ;
44964   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
44965   unsigned int arg2 ;
44966   unsigned int arg3 ;
44967   Dali::Pixel::Format arg4 ;
44968   Dali::BufferImage result;
44969
44970   arg1 = jarg1;
44971   arg2 = (unsigned int)jarg2;
44972   arg3 = (unsigned int)jarg3;
44973   arg4 = (Dali::Pixel::Format)jarg4;
44974   {
44975     try {
44976       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
44977     } catch (std::out_of_range& e) {
44978       {
44979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44980       };
44981     } catch (std::exception& e) {
44982       {
44983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44984       };
44985     } catch (Dali::DaliException e) {
44986       {
44987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44988       };
44989     } catch (...) {
44990       {
44991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44992       };
44993     }
44994   }
44995
44996   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
44997
44998
44999   return jresult;
45000 }
45001
45002
45003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45004   void * jresult ;
45005   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45006   unsigned int arg2 ;
45007   unsigned int arg3 ;
45008   Dali::BufferImage result;
45009
45010   arg1 = jarg1;
45011   arg2 = (unsigned int)jarg2;
45012   arg3 = (unsigned int)jarg3;
45013   {
45014     try {
45015       result = Dali::BufferImage::New(arg1,arg2,arg3);
45016     } catch (std::out_of_range& e) {
45017       {
45018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45019       };
45020     } catch (std::exception& e) {
45021       {
45022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45023       };
45024     } catch (Dali::DaliException e) {
45025       {
45026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45027       };
45028     } catch (...) {
45029       {
45030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45031       };
45032     }
45033   }
45034
45035   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45036
45037
45038   return jresult;
45039 }
45040
45041
45042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45043   void * jresult ;
45044   Dali::BaseHandle arg1 ;
45045   Dali::BaseHandle *argp1 ;
45046   Dali::BufferImage result;
45047
45048   argp1 = (Dali::BaseHandle *)jarg1;
45049   if (!argp1) {
45050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45051     return 0;
45052   }
45053   arg1 = *argp1;
45054   {
45055     try {
45056       result = Dali::BufferImage::DownCast(arg1);
45057     } catch (std::out_of_range& e) {
45058       {
45059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (std::exception& e) {
45062       {
45063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45064       };
45065     } catch (Dali::DaliException e) {
45066       {
45067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45068       };
45069     } catch (...) {
45070       {
45071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45072       };
45073     }
45074   }
45075
45076   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45077   return jresult;
45078 }
45079
45080
45081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45082   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45083
45084   arg1 = (Dali::BufferImage *)jarg1;
45085   {
45086     try {
45087       delete arg1;
45088     } catch (std::out_of_range& e) {
45089       {
45090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45091       };
45092     } catch (std::exception& e) {
45093       {
45094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45095       };
45096     } catch (Dali::DaliException e) {
45097       {
45098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45099       };
45100     } catch (...) {
45101       {
45102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45103       };
45104     }
45105   }
45106
45107 }
45108
45109
45110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45111   void * jresult ;
45112   Dali::BufferImage *arg1 = 0 ;
45113   Dali::BufferImage *result = 0 ;
45114
45115   arg1 = (Dali::BufferImage *)jarg1;
45116   if (!arg1) {
45117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45118     return 0;
45119   }
45120   {
45121     try {
45122       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45123     } catch (std::out_of_range& e) {
45124       {
45125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45126       };
45127     } catch (std::exception& e) {
45128       {
45129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (Dali::DaliException e) {
45132       {
45133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141
45142   jresult = (void *)result;
45143   return jresult;
45144 }
45145
45146
45147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45148   void * jresult ;
45149   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45150   Dali::BufferImage *arg2 = 0 ;
45151   Dali::BufferImage *result = 0 ;
45152
45153   arg1 = (Dali::BufferImage *)jarg1;
45154   arg2 = (Dali::BufferImage *)jarg2;
45155   if (!arg2) {
45156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45157     return 0;
45158   }
45159   {
45160     try {
45161       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = (void *)result;
45182   return jresult;
45183 }
45184
45185
45186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45187   void * jresult ;
45188   Dali::BufferImage result;
45189
45190   {
45191     try {
45192       result = Dali::BufferImage::WHITE();
45193     } catch (std::out_of_range& e) {
45194       {
45195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45196       };
45197     } catch (std::exception& e) {
45198       {
45199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (Dali::DaliException e) {
45202       {
45203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45204       };
45205     } catch (...) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45208       };
45209     }
45210   }
45211
45212   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45213   return jresult;
45214 }
45215
45216
45217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45218   void * jresult ;
45219   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45220   Dali::PixelBuffer *result = 0 ;
45221
45222   arg1 = (Dali::BufferImage *)jarg1;
45223   {
45224     try {
45225       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45226     } catch (std::out_of_range& e) {
45227       {
45228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45229       };
45230     } catch (std::exception& e) {
45231       {
45232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45233       };
45234     } catch (Dali::DaliException e) {
45235       {
45236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45237       };
45238     } catch (...) {
45239       {
45240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45241       };
45242     }
45243   }
45244
45245   jresult = (void *)result;
45246   return jresult;
45247 }
45248
45249
45250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45251   unsigned int jresult ;
45252   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45253   unsigned int result;
45254
45255   arg1 = (Dali::BufferImage *)jarg1;
45256   {
45257     try {
45258       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45259     } catch (std::out_of_range& e) {
45260       {
45261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45262       };
45263     } catch (std::exception& e) {
45264       {
45265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45266       };
45267     } catch (Dali::DaliException e) {
45268       {
45269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45270       };
45271     } catch (...) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45274       };
45275     }
45276   }
45277
45278   jresult = result;
45279   return jresult;
45280 }
45281
45282
45283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45284   unsigned int jresult ;
45285   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45286   unsigned int result;
45287
45288   arg1 = (Dali::BufferImage *)jarg1;
45289   {
45290     try {
45291       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45292     } catch (std::out_of_range& e) {
45293       {
45294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45295       };
45296     } catch (std::exception& e) {
45297       {
45298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45299       };
45300     } catch (Dali::DaliException e) {
45301       {
45302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45303       };
45304     } catch (...) {
45305       {
45306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45307       };
45308     }
45309   }
45310
45311   jresult = result;
45312   return jresult;
45313 }
45314
45315
45316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45317   int jresult ;
45318   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45319   Dali::Pixel::Format result;
45320
45321   arg1 = (Dali::BufferImage *)jarg1;
45322   {
45323     try {
45324       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45325     } catch (std::out_of_range& e) {
45326       {
45327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45328       };
45329     } catch (std::exception& e) {
45330       {
45331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45332       };
45333     } catch (Dali::DaliException e) {
45334       {
45335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45336       };
45337     } catch (...) {
45338       {
45339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45340       };
45341     }
45342   }
45343
45344   jresult = (int)result;
45345   return jresult;
45346 }
45347
45348
45349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45350   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45351
45352   arg1 = (Dali::BufferImage *)jarg1;
45353   {
45354     try {
45355       (arg1)->Update();
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45363       };
45364     } catch (Dali::DaliException e) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45367       };
45368     } catch (...) {
45369       {
45370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45371       };
45372     }
45373   }
45374
45375 }
45376
45377
45378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45379   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45380   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45381   Dali::RectArea *argp2 ;
45382
45383   arg1 = (Dali::BufferImage *)jarg1;
45384   argp2 = (Dali::RectArea *)jarg2;
45385   if (!argp2) {
45386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45387     return ;
45388   }
45389   arg2 = *argp2;
45390   {
45391     try {
45392       (arg1)->Update(arg2);
45393     } catch (std::out_of_range& e) {
45394       {
45395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45396       };
45397     } catch (std::exception& e) {
45398       {
45399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45400       };
45401     } catch (Dali::DaliException e) {
45402       {
45403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45404       };
45405     } catch (...) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45408       };
45409     }
45410   }
45411
45412 }
45413
45414
45415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45416   unsigned int jresult ;
45417   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45418   bool result;
45419
45420   arg1 = (Dali::BufferImage *)jarg1;
45421   {
45422     try {
45423       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45424     } catch (std::out_of_range& e) {
45425       {
45426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45427       };
45428     } catch (std::exception& e) {
45429       {
45430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45431       };
45432     } catch (Dali::DaliException e) {
45433       {
45434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45435       };
45436     } catch (...) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45439       };
45440     }
45441   }
45442
45443   jresult = result;
45444   return jresult;
45445 }
45446
45447
45448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45449   void * jresult ;
45450   Dali::EncodedBufferImage *result = 0 ;
45451
45452   {
45453     try {
45454       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45455     } catch (std::out_of_range& e) {
45456       {
45457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45458       };
45459     } catch (std::exception& e) {
45460       {
45461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45462       };
45463     } catch (Dali::DaliException e) {
45464       {
45465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45466       };
45467     } catch (...) {
45468       {
45469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45470       };
45471     }
45472   }
45473
45474   jresult = (void *)result;
45475   return jresult;
45476 }
45477
45478
45479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45480   void * jresult ;
45481   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45482   std::size_t arg2 ;
45483   Dali::EncodedBufferImage result;
45484
45485   arg1 = (uint8_t *)jarg1;
45486   arg2 = (std::size_t)jarg2;
45487   {
45488     try {
45489       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45490     } catch (std::out_of_range& e) {
45491       {
45492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45493       };
45494     } catch (std::exception& e) {
45495       {
45496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45497       };
45498     } catch (Dali::DaliException e) {
45499       {
45500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45501       };
45502     } catch (...) {
45503       {
45504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45505       };
45506     }
45507   }
45508
45509   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45510   return jresult;
45511 }
45512
45513
45514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45515   void * jresult ;
45516   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45517   std::size_t arg2 ;
45518   Dali::ImageDimensions arg3 ;
45519   Dali::FittingMode::Type arg4 ;
45520   Dali::SamplingMode::Type arg5 ;
45521   bool arg6 ;
45522   Dali::ImageDimensions *argp3 ;
45523   Dali::EncodedBufferImage result;
45524
45525   arg1 = (uint8_t *)jarg1;
45526   arg2 = (std::size_t)jarg2;
45527   argp3 = (Dali::ImageDimensions *)jarg3;
45528   if (!argp3) {
45529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45530     return 0;
45531   }
45532   arg3 = *argp3;
45533   arg4 = (Dali::FittingMode::Type)jarg4;
45534   arg5 = (Dali::SamplingMode::Type)jarg5;
45535   arg6 = jarg6 ? true : false;
45536   {
45537     try {
45538       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45546       };
45547     } catch (Dali::DaliException e) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45550       };
45551     } catch (...) {
45552       {
45553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45554       };
45555     }
45556   }
45557
45558   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45559   return jresult;
45560 }
45561
45562
45563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45564   void * jresult ;
45565   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45566   std::size_t arg2 ;
45567   Dali::ImageDimensions arg3 ;
45568   Dali::FittingMode::Type arg4 ;
45569   Dali::SamplingMode::Type arg5 ;
45570   Dali::ImageDimensions *argp3 ;
45571   Dali::EncodedBufferImage result;
45572
45573   arg1 = (uint8_t *)jarg1;
45574   arg2 = (std::size_t)jarg2;
45575   argp3 = (Dali::ImageDimensions *)jarg3;
45576   if (!argp3) {
45577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45578     return 0;
45579   }
45580   arg3 = *argp3;
45581   arg4 = (Dali::FittingMode::Type)jarg4;
45582   arg5 = (Dali::SamplingMode::Type)jarg5;
45583   {
45584     try {
45585       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45586     } catch (std::out_of_range& e) {
45587       {
45588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (std::exception& e) {
45591       {
45592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45593       };
45594     } catch (Dali::DaliException e) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45597       };
45598     } catch (...) {
45599       {
45600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45601       };
45602     }
45603   }
45604
45605   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45606   return jresult;
45607 }
45608
45609
45610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45611   void * jresult ;
45612   Dali::BaseHandle arg1 ;
45613   Dali::BaseHandle *argp1 ;
45614   Dali::EncodedBufferImage result;
45615
45616   argp1 = (Dali::BaseHandle *)jarg1;
45617   if (!argp1) {
45618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45619     return 0;
45620   }
45621   arg1 = *argp1;
45622   {
45623     try {
45624       result = Dali::EncodedBufferImage::DownCast(arg1);
45625     } catch (std::out_of_range& e) {
45626       {
45627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45628       };
45629     } catch (std::exception& e) {
45630       {
45631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45632       };
45633     } catch (Dali::DaliException e) {
45634       {
45635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45636       };
45637     } catch (...) {
45638       {
45639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45640       };
45641     }
45642   }
45643
45644   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45650   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45651
45652   arg1 = (Dali::EncodedBufferImage *)jarg1;
45653   {
45654     try {
45655       delete arg1;
45656     } catch (std::out_of_range& e) {
45657       {
45658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45659       };
45660     } catch (std::exception& e) {
45661       {
45662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45663       };
45664     } catch (Dali::DaliException e) {
45665       {
45666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45667       };
45668     } catch (...) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45671       };
45672     }
45673   }
45674
45675 }
45676
45677
45678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45679   void * jresult ;
45680   Dali::EncodedBufferImage *arg1 = 0 ;
45681   Dali::EncodedBufferImage *result = 0 ;
45682
45683   arg1 = (Dali::EncodedBufferImage *)jarg1;
45684   if (!arg1) {
45685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45686     return 0;
45687   }
45688   {
45689     try {
45690       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45691     } catch (std::out_of_range& e) {
45692       {
45693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45694       };
45695     } catch (std::exception& e) {
45696       {
45697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (Dali::DaliException e) {
45700       {
45701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45702       };
45703     } catch (...) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45706       };
45707     }
45708   }
45709
45710   jresult = (void *)result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45716   void * jresult ;
45717   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45718   Dali::EncodedBufferImage *arg2 = 0 ;
45719   Dali::EncodedBufferImage *result = 0 ;
45720
45721   arg1 = (Dali::EncodedBufferImage *)jarg1;
45722   arg2 = (Dali::EncodedBufferImage *)jarg2;
45723   if (!arg2) {
45724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45725     return 0;
45726   }
45727   {
45728     try {
45729       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45730     } catch (std::out_of_range& e) {
45731       {
45732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45733       };
45734     } catch (std::exception& e) {
45735       {
45736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45737       };
45738     } catch (Dali::DaliException e) {
45739       {
45740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45741       };
45742     } catch (...) {
45743       {
45744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45745       };
45746     }
45747   }
45748
45749   jresult = (void *)result;
45750   return jresult;
45751 }
45752
45753
45754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45755   void * jresult ;
45756   Dali::NativeImage *result = 0 ;
45757
45758   {
45759     try {
45760       result = (Dali::NativeImage *)new Dali::NativeImage();
45761     } catch (std::out_of_range& e) {
45762       {
45763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (std::exception& e) {
45766       {
45767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (Dali::DaliException e) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779
45780   jresult = (void *)result;
45781   return jresult;
45782 }
45783
45784
45785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45786   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45787
45788   arg1 = (Dali::NativeImage *)jarg1;
45789   {
45790     try {
45791       delete arg1;
45792     } catch (std::out_of_range& e) {
45793       {
45794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45795       };
45796     } catch (std::exception& e) {
45797       {
45798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45799       };
45800     } catch (Dali::DaliException e) {
45801       {
45802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45803       };
45804     } catch (...) {
45805       {
45806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45807       };
45808     }
45809   }
45810
45811 }
45812
45813
45814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45815   void * jresult ;
45816   Dali::NativeImage *arg1 = 0 ;
45817   Dali::NativeImage *result = 0 ;
45818
45819   arg1 = (Dali::NativeImage *)jarg1;
45820   if (!arg1) {
45821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45822     return 0;
45823   }
45824   {
45825     try {
45826       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45827     } catch (std::out_of_range& e) {
45828       {
45829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45830       };
45831     } catch (std::exception& e) {
45832       {
45833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45834       };
45835     } catch (Dali::DaliException e) {
45836       {
45837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45838       };
45839     } catch (...) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45842       };
45843     }
45844   }
45845
45846   jresult = (void *)result;
45847   return jresult;
45848 }
45849
45850
45851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45852   void * jresult ;
45853   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45854   Dali::NativeImage *arg2 = 0 ;
45855   Dali::NativeImage *result = 0 ;
45856
45857   arg1 = (Dali::NativeImage *)jarg1;
45858   arg2 = (Dali::NativeImage *)jarg2;
45859   if (!arg2) {
45860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45861     return 0;
45862   }
45863   {
45864     try {
45865       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
45866     } catch (std::out_of_range& e) {
45867       {
45868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (std::exception& e) {
45871       {
45872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45873       };
45874     } catch (Dali::DaliException e) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45877       };
45878     } catch (...) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45881       };
45882     }
45883   }
45884
45885   jresult = (void *)result;
45886   return jresult;
45887 }
45888
45889
45890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45891   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45892
45893   arg1 = (Dali::NativeImage *)jarg1;
45894   {
45895     try {
45896       (arg1)->CreateGlTexture();
45897     } catch (std::out_of_range& e) {
45898       {
45899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45900       };
45901     } catch (std::exception& e) {
45902       {
45903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45904       };
45905     } catch (Dali::DaliException e) {
45906       {
45907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45908       };
45909     } catch (...) {
45910       {
45911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45912       };
45913     }
45914   }
45915
45916 }
45917
45918
45919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45920   void * jresult ;
45921   NativeImageInterface *arg1 = 0 ;
45922   Dali::NativeImage result;
45923
45924   arg1 = (NativeImageInterface *)jarg1;
45925   if (!arg1) {
45926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45927     return 0;
45928   }
45929   {
45930     try {
45931       result = Dali::NativeImage::New(*arg1);
45932     } catch (std::out_of_range& e) {
45933       {
45934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45935       };
45936     } catch (std::exception& e) {
45937       {
45938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (Dali::DaliException e) {
45941       {
45942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45943       };
45944     } catch (...) {
45945       {
45946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45947       };
45948     }
45949   }
45950
45951   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45957   void * jresult ;
45958   Dali::BaseHandle arg1 ;
45959   Dali::BaseHandle *argp1 ;
45960   Dali::NativeImage result;
45961
45962   argp1 = (Dali::BaseHandle *)jarg1;
45963   if (!argp1) {
45964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45965     return 0;
45966   }
45967   arg1 = *argp1;
45968   {
45969     try {
45970       result = Dali::NativeImage::DownCast(arg1);
45971     } catch (std::out_of_range& e) {
45972       {
45973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45974       };
45975     } catch (std::exception& e) {
45976       {
45977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45978       };
45979     } catch (Dali::DaliException e) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45982       };
45983     } catch (...) {
45984       {
45985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45986       };
45987     }
45988   }
45989
45990   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45991   return jresult;
45992 }
45993
45994
45995 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
45996   char * jresult ;
45997   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45998   char *result = 0 ;
45999
46000   arg1 = (Dali::NativeImage *)jarg1;
46001   {
46002     try {
46003       result = (char *)(arg1)->GetCustomFragmentPreFix();
46004     } catch (std::out_of_range& e) {
46005       {
46006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46007       };
46008     } catch (std::exception& e) {
46009       {
46010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46011       };
46012     } catch (Dali::DaliException e) {
46013       {
46014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46015       };
46016     } catch (...) {
46017       {
46018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46019       };
46020     }
46021   }
46022
46023   jresult = SWIG_csharp_string_callback((const char *)result);
46024   return jresult;
46025 }
46026
46027
46028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46029   char * jresult ;
46030   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46031   char *result = 0 ;
46032
46033   arg1 = (Dali::NativeImage *)jarg1;
46034   {
46035     try {
46036       result = (char *)(arg1)->GetCustomSamplerTypename();
46037     } catch (std::out_of_range& e) {
46038       {
46039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (std::exception& e) {
46042       {
46043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (Dali::DaliException e) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46048       };
46049     } catch (...) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46052       };
46053     }
46054   }
46055
46056   jresult = SWIG_csharp_string_callback((const char *)result);
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46062   unsigned int jresult ;
46063   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46064   bool result;
46065
46066   arg1 = (Dali::NativeImageInterface *)jarg1;
46067   {
46068     try {
46069       result = (bool)(arg1)->GlExtensionCreate();
46070     } catch (std::out_of_range& e) {
46071       {
46072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46073       };
46074     } catch (std::exception& e) {
46075       {
46076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46077       };
46078     } catch (Dali::DaliException e) {
46079       {
46080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46081       };
46082     } catch (...) {
46083       {
46084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46085       };
46086     }
46087   }
46088
46089   jresult = result;
46090   return jresult;
46091 }
46092
46093
46094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46095   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46096
46097   arg1 = (Dali::NativeImageInterface *)jarg1;
46098   {
46099     try {
46100       (arg1)->GlExtensionDestroy();
46101     } catch (std::out_of_range& e) {
46102       {
46103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46104       };
46105     } catch (std::exception& e) {
46106       {
46107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46108       };
46109     } catch (Dali::DaliException e) {
46110       {
46111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46112       };
46113     } catch (...) {
46114       {
46115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46116       };
46117     }
46118   }
46119
46120 }
46121
46122
46123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46124   unsigned int jresult ;
46125   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46126   unsigned int result;
46127
46128   arg1 = (Dali::NativeImageInterface *)jarg1;
46129   {
46130     try {
46131       result = (unsigned int)(arg1)->TargetTexture();
46132     } catch (std::out_of_range& e) {
46133       {
46134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46135       };
46136     } catch (std::exception& e) {
46137       {
46138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46139       };
46140     } catch (Dali::DaliException e) {
46141       {
46142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46143       };
46144     } catch (...) {
46145       {
46146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46147       };
46148     }
46149   }
46150
46151   jresult = result;
46152   return jresult;
46153 }
46154
46155
46156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46157   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46158
46159   arg1 = (Dali::NativeImageInterface *)jarg1;
46160   {
46161     try {
46162       (arg1)->PrepareTexture();
46163     } catch (std::out_of_range& e) {
46164       {
46165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46166       };
46167     } catch (std::exception& e) {
46168       {
46169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46170       };
46171     } catch (Dali::DaliException e) {
46172       {
46173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46174       };
46175     } catch (...) {
46176       {
46177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46178       };
46179     }
46180   }
46181
46182 }
46183
46184
46185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46186   unsigned int jresult ;
46187   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46188   unsigned int result;
46189
46190   arg1 = (Dali::NativeImageInterface *)jarg1;
46191   {
46192     try {
46193       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46194     } catch (std::out_of_range& e) {
46195       {
46196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46197       };
46198     } catch (std::exception& e) {
46199       {
46200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46201       };
46202     } catch (Dali::DaliException e) {
46203       {
46204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46205       };
46206     } catch (...) {
46207       {
46208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46209       };
46210     }
46211   }
46212
46213   jresult = result;
46214   return jresult;
46215 }
46216
46217
46218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46219   unsigned int jresult ;
46220   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46221   unsigned int result;
46222
46223   arg1 = (Dali::NativeImageInterface *)jarg1;
46224   {
46225     try {
46226       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46227     } catch (std::out_of_range& e) {
46228       {
46229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46230       };
46231     } catch (std::exception& e) {
46232       {
46233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46234       };
46235     } catch (Dali::DaliException e) {
46236       {
46237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46238       };
46239     } catch (...) {
46240       {
46241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46242       };
46243     }
46244   }
46245
46246   jresult = result;
46247   return jresult;
46248 }
46249
46250
46251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46252   unsigned int jresult ;
46253   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46254   bool result;
46255
46256   arg1 = (Dali::NativeImageInterface *)jarg1;
46257   {
46258     try {
46259       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46260     } catch (std::out_of_range& e) {
46261       {
46262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46263       };
46264     } catch (std::exception& e) {
46265       {
46266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46267       };
46268     } catch (Dali::DaliException e) {
46269       {
46270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46271       };
46272     } catch (...) {
46273       {
46274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46275       };
46276     }
46277   }
46278
46279   jresult = result;
46280   return jresult;
46281 }
46282
46283
46284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46285   void * jresult ;
46286   std::string *arg1 = 0 ;
46287   Dali::ImageDimensions result;
46288
46289   if (!jarg1) {
46290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46291     return 0;
46292   }
46293   std::string arg1_str(jarg1);
46294   arg1 = &arg1_str;
46295   {
46296     try {
46297       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46298     } catch (std::out_of_range& e) {
46299       {
46300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46301       };
46302     } catch (std::exception& e) {
46303       {
46304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46305       };
46306     } catch (Dali::DaliException e) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46309       };
46310     } catch (...) {
46311       {
46312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46313       };
46314     }
46315   }
46316
46317   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46318
46319   //argout typemap for const std::string&
46320
46321   return jresult;
46322 }
46323
46324
46325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46326   void * jresult ;
46327   Dali::ResourceImage *result = 0 ;
46328
46329   {
46330     try {
46331       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46332     } catch (std::out_of_range& e) {
46333       {
46334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46335       };
46336     } catch (std::exception& e) {
46337       {
46338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46339       };
46340     } catch (Dali::DaliException e) {
46341       {
46342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46343       };
46344     } catch (...) {
46345       {
46346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46347       };
46348     }
46349   }
46350
46351   jresult = (void *)result;
46352   return jresult;
46353 }
46354
46355
46356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46357   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46358
46359   arg1 = (Dali::ResourceImage *)jarg1;
46360   {
46361     try {
46362       delete arg1;
46363     } catch (std::out_of_range& e) {
46364       {
46365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46366       };
46367     } catch (std::exception& e) {
46368       {
46369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46370       };
46371     } catch (Dali::DaliException e) {
46372       {
46373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46374       };
46375     } catch (...) {
46376       {
46377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46378       };
46379     }
46380   }
46381
46382 }
46383
46384
46385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46386   void * jresult ;
46387   Dali::ResourceImage *arg1 = 0 ;
46388   Dali::ResourceImage *result = 0 ;
46389
46390   arg1 = (Dali::ResourceImage *)jarg1;
46391   if (!arg1) {
46392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46393     return 0;
46394   }
46395   {
46396     try {
46397       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (Dali::DaliException e) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46413       };
46414     }
46415   }
46416
46417   jresult = (void *)result;
46418   return jresult;
46419 }
46420
46421
46422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46423   void * jresult ;
46424   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46425   Dali::ResourceImage *arg2 = 0 ;
46426   Dali::ResourceImage *result = 0 ;
46427
46428   arg1 = (Dali::ResourceImage *)jarg1;
46429   arg2 = (Dali::ResourceImage *)jarg2;
46430   if (!arg2) {
46431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46432     return 0;
46433   }
46434   {
46435     try {
46436       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46437     } catch (std::out_of_range& e) {
46438       {
46439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46440       };
46441     } catch (std::exception& e) {
46442       {
46443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46444       };
46445     } catch (Dali::DaliException e) {
46446       {
46447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46448       };
46449     } catch (...) {
46450       {
46451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46452       };
46453     }
46454   }
46455
46456   jresult = (void *)result;
46457   return jresult;
46458 }
46459
46460
46461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46462   void * jresult ;
46463   std::string *arg1 = 0 ;
46464   bool arg2 ;
46465   Dali::ResourceImage result;
46466
46467   if (!jarg1) {
46468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46469     return 0;
46470   }
46471   std::string arg1_str(jarg1);
46472   arg1 = &arg1_str;
46473   arg2 = jarg2 ? true : false;
46474   {
46475     try {
46476       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46477     } catch (std::out_of_range& e) {
46478       {
46479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46480       };
46481     } catch (std::exception& e) {
46482       {
46483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46484       };
46485     } catch (Dali::DaliException e) {
46486       {
46487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46488       };
46489     } catch (...) {
46490       {
46491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46492       };
46493     }
46494   }
46495
46496   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46497
46498   //argout typemap for const std::string&
46499
46500   return jresult;
46501 }
46502
46503
46504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46505   void * jresult ;
46506   std::string *arg1 = 0 ;
46507   Dali::ResourceImage result;
46508
46509   if (!jarg1) {
46510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46511     return 0;
46512   }
46513   std::string arg1_str(jarg1);
46514   arg1 = &arg1_str;
46515   {
46516     try {
46517       result = Dali::ResourceImage::New((std::string const &)*arg1);
46518     } catch (std::out_of_range& e) {
46519       {
46520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46521       };
46522     } catch (std::exception& e) {
46523       {
46524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46525       };
46526     } catch (Dali::DaliException e) {
46527       {
46528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46529       };
46530     } catch (...) {
46531       {
46532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46533       };
46534     }
46535   }
46536
46537   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46538
46539   //argout typemap for const std::string&
46540
46541   return jresult;
46542 }
46543
46544
46545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46546   void * jresult ;
46547   std::string *arg1 = 0 ;
46548   Dali::ImageDimensions arg2 ;
46549   Dali::FittingMode::Type arg3 ;
46550   Dali::SamplingMode::Type arg4 ;
46551   bool arg5 ;
46552   Dali::ImageDimensions *argp2 ;
46553   Dali::ResourceImage result;
46554
46555   if (!jarg1) {
46556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46557     return 0;
46558   }
46559   std::string arg1_str(jarg1);
46560   arg1 = &arg1_str;
46561   argp2 = (Dali::ImageDimensions *)jarg2;
46562   if (!argp2) {
46563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46564     return 0;
46565   }
46566   arg2 = *argp2;
46567   arg3 = (Dali::FittingMode::Type)jarg3;
46568   arg4 = (Dali::SamplingMode::Type)jarg4;
46569   arg5 = jarg5 ? true : false;
46570   {
46571     try {
46572       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46580       };
46581     } catch (Dali::DaliException e) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46584       };
46585     } catch (...) {
46586       {
46587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46588       };
46589     }
46590   }
46591
46592   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46593
46594   //argout typemap for const std::string&
46595
46596   return jresult;
46597 }
46598
46599
46600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46601   void * jresult ;
46602   std::string *arg1 = 0 ;
46603   Dali::ImageDimensions arg2 ;
46604   Dali::FittingMode::Type arg3 ;
46605   Dali::SamplingMode::Type arg4 ;
46606   Dali::ImageDimensions *argp2 ;
46607   Dali::ResourceImage result;
46608
46609   if (!jarg1) {
46610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46611     return 0;
46612   }
46613   std::string arg1_str(jarg1);
46614   arg1 = &arg1_str;
46615   argp2 = (Dali::ImageDimensions *)jarg2;
46616   if (!argp2) {
46617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46618     return 0;
46619   }
46620   arg2 = *argp2;
46621   arg3 = (Dali::FittingMode::Type)jarg3;
46622   arg4 = (Dali::SamplingMode::Type)jarg4;
46623   {
46624     try {
46625       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46626     } catch (std::out_of_range& e) {
46627       {
46628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46629       };
46630     } catch (std::exception& e) {
46631       {
46632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46633       };
46634     } catch (Dali::DaliException e) {
46635       {
46636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46637       };
46638     } catch (...) {
46639       {
46640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46641       };
46642     }
46643   }
46644
46645   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46646
46647   //argout typemap for const std::string&
46648
46649   return jresult;
46650 }
46651
46652
46653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46654   void * jresult ;
46655   std::string *arg1 = 0 ;
46656   Dali::ImageDimensions arg2 ;
46657   Dali::FittingMode::Type arg3 ;
46658   Dali::ImageDimensions *argp2 ;
46659   Dali::ResourceImage result;
46660
46661   if (!jarg1) {
46662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46663     return 0;
46664   }
46665   std::string arg1_str(jarg1);
46666   arg1 = &arg1_str;
46667   argp2 = (Dali::ImageDimensions *)jarg2;
46668   if (!argp2) {
46669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46670     return 0;
46671   }
46672   arg2 = *argp2;
46673   arg3 = (Dali::FittingMode::Type)jarg3;
46674   {
46675     try {
46676       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46677     } catch (std::out_of_range& e) {
46678       {
46679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46680       };
46681     } catch (std::exception& e) {
46682       {
46683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46684       };
46685     } catch (Dali::DaliException e) {
46686       {
46687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46688       };
46689     } catch (...) {
46690       {
46691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46692       };
46693     }
46694   }
46695
46696   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46697
46698   //argout typemap for const std::string&
46699
46700   return jresult;
46701 }
46702
46703
46704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46705   void * jresult ;
46706   std::string *arg1 = 0 ;
46707   Dali::ImageDimensions arg2 ;
46708   Dali::ImageDimensions *argp2 ;
46709   Dali::ResourceImage result;
46710
46711   if (!jarg1) {
46712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46713     return 0;
46714   }
46715   std::string arg1_str(jarg1);
46716   arg1 = &arg1_str;
46717   argp2 = (Dali::ImageDimensions *)jarg2;
46718   if (!argp2) {
46719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46720     return 0;
46721   }
46722   arg2 = *argp2;
46723   {
46724     try {
46725       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46726     } catch (std::out_of_range& e) {
46727       {
46728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46729       };
46730     } catch (std::exception& e) {
46731       {
46732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46733       };
46734     } catch (Dali::DaliException e) {
46735       {
46736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46737       };
46738     } catch (...) {
46739       {
46740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46741       };
46742     }
46743   }
46744
46745   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46746
46747   //argout typemap for const std::string&
46748
46749   return jresult;
46750 }
46751
46752
46753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46754   void * jresult ;
46755   Dali::BaseHandle arg1 ;
46756   Dali::BaseHandle *argp1 ;
46757   Dali::ResourceImage result;
46758
46759   argp1 = (Dali::BaseHandle *)jarg1;
46760   if (!argp1) {
46761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46762     return 0;
46763   }
46764   arg1 = *argp1;
46765   {
46766     try {
46767       result = Dali::ResourceImage::DownCast(arg1);
46768     } catch (std::out_of_range& e) {
46769       {
46770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46771       };
46772     } catch (std::exception& e) {
46773       {
46774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46775       };
46776     } catch (Dali::DaliException e) {
46777       {
46778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46779       };
46780     } catch (...) {
46781       {
46782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46783       };
46784     }
46785   }
46786
46787   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46793   int jresult ;
46794   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46795   Dali::LoadingState result;
46796
46797   arg1 = (Dali::ResourceImage *)jarg1;
46798   {
46799     try {
46800       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46801     } catch (std::out_of_range& e) {
46802       {
46803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (std::exception& e) {
46806       {
46807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46808       };
46809     } catch (Dali::DaliException e) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46812       };
46813     } catch (...) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46816       };
46817     }
46818   }
46819
46820   jresult = (int)result;
46821   return jresult;
46822 }
46823
46824
46825 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46826   char * jresult ;
46827   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46828   std::string result;
46829
46830   arg1 = (Dali::ResourceImage *)jarg1;
46831   {
46832     try {
46833       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46841       };
46842     } catch (Dali::DaliException e) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46849       };
46850     }
46851   }
46852
46853   jresult = SWIG_csharp_string_callback((&result)->c_str());
46854   return jresult;
46855 }
46856
46857
46858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
46859   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46860
46861   arg1 = (Dali::ResourceImage *)jarg1;
46862   {
46863     try {
46864       (arg1)->Reload();
46865     } catch (std::out_of_range& e) {
46866       {
46867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46868       };
46869     } catch (std::exception& e) {
46870       {
46871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46872       };
46873     } catch (Dali::DaliException e) {
46874       {
46875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46876       };
46877     } catch (...) {
46878       {
46879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46880       };
46881     }
46882   }
46883
46884 }
46885
46886
46887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
46888   void * jresult ;
46889   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46890   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46891
46892   arg1 = (Dali::ResourceImage *)jarg1;
46893   {
46894     try {
46895       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46896     } catch (std::out_of_range& e) {
46897       {
46898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46899       };
46900     } catch (std::exception& e) {
46901       {
46902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46903       };
46904     } catch (Dali::DaliException e) {
46905       {
46906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46907       };
46908     } catch (...) {
46909       {
46910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46911       };
46912     }
46913   }
46914
46915   jresult = (void *)result;
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46921   void * jresult ;
46922   Dali::FrameBufferImage *result = 0 ;
46923
46924   {
46925     try {
46926       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46927     } catch (std::out_of_range& e) {
46928       {
46929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46930       };
46931     } catch (std::exception& e) {
46932       {
46933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46934       };
46935     } catch (Dali::DaliException e) {
46936       {
46937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46938       };
46939     } catch (...) {
46940       {
46941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46942       };
46943     }
46944   }
46945
46946   jresult = (void *)result;
46947   return jresult;
46948 }
46949
46950
46951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46952   void * jresult ;
46953   unsigned int arg1 ;
46954   unsigned int arg2 ;
46955   Dali::Pixel::Format arg3 ;
46956   Dali::RenderBuffer::Format arg4 ;
46957   Dali::FrameBufferImage result;
46958
46959   arg1 = (unsigned int)jarg1;
46960   arg2 = (unsigned int)jarg2;
46961   arg3 = (Dali::Pixel::Format)jarg3;
46962   arg4 = (Dali::RenderBuffer::Format)jarg4;
46963   {
46964     try {
46965       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
46966     } catch (std::out_of_range& e) {
46967       {
46968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46969       };
46970     } catch (std::exception& e) {
46971       {
46972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46973       };
46974     } catch (Dali::DaliException e) {
46975       {
46976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46977       };
46978     } catch (...) {
46979       {
46980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46981       };
46982     }
46983   }
46984
46985   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46986   return jresult;
46987 }
46988
46989
46990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
46991   void * jresult ;
46992   unsigned int arg1 ;
46993   unsigned int arg2 ;
46994   Dali::Pixel::Format arg3 ;
46995   Dali::FrameBufferImage result;
46996
46997   arg1 = (unsigned int)jarg1;
46998   arg2 = (unsigned int)jarg2;
46999   arg3 = (Dali::Pixel::Format)jarg3;
47000   {
47001     try {
47002       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (Dali::DaliException e) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47014       };
47015     } catch (...) {
47016       {
47017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47018       };
47019     }
47020   }
47021
47022   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47023   return jresult;
47024 }
47025
47026
47027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47028   void * jresult ;
47029   unsigned int arg1 ;
47030   unsigned int arg2 ;
47031   Dali::FrameBufferImage result;
47032
47033   arg1 = (unsigned int)jarg1;
47034   arg2 = (unsigned int)jarg2;
47035   {
47036     try {
47037       result = Dali::FrameBufferImage::New(arg1,arg2);
47038     } catch (std::out_of_range& e) {
47039       {
47040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47041       };
47042     } catch (std::exception& e) {
47043       {
47044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47045       };
47046     } catch (Dali::DaliException e) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47049       };
47050     } catch (...) {
47051       {
47052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47053       };
47054     }
47055   }
47056
47057   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47058   return jresult;
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47063   void * jresult ;
47064   unsigned int arg1 ;
47065   Dali::FrameBufferImage result;
47066
47067   arg1 = (unsigned int)jarg1;
47068   {
47069     try {
47070       result = Dali::FrameBufferImage::New(arg1);
47071     } catch (std::out_of_range& e) {
47072       {
47073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (std::exception& e) {
47076       {
47077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (Dali::DaliException e) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47082       };
47083     } catch (...) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47086       };
47087     }
47088   }
47089
47090   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47091   return jresult;
47092 }
47093
47094
47095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47096   void * jresult ;
47097   Dali::FrameBufferImage result;
47098
47099   {
47100     try {
47101       result = Dali::FrameBufferImage::New();
47102     } catch (std::out_of_range& e) {
47103       {
47104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (std::exception& e) {
47107       {
47108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (Dali::DaliException e) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47113       };
47114     } catch (...) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47117       };
47118     }
47119   }
47120
47121   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47122   return jresult;
47123 }
47124
47125
47126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47127   void * jresult ;
47128   Dali::NativeImageInterface *arg1 = 0 ;
47129   Dali::FrameBufferImage result;
47130
47131   arg1 = (Dali::NativeImageInterface *)jarg1;
47132   if (!arg1) {
47133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47134     return 0;
47135   }
47136   {
47137     try {
47138       result = Dali::FrameBufferImage::New(*arg1);
47139     } catch (std::out_of_range& e) {
47140       {
47141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47142       };
47143     } catch (std::exception& e) {
47144       {
47145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47146       };
47147     } catch (Dali::DaliException e) {
47148       {
47149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47150       };
47151     } catch (...) {
47152       {
47153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47154       };
47155     }
47156   }
47157
47158   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47159   return jresult;
47160 }
47161
47162
47163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47164   void * jresult ;
47165   Dali::BaseHandle arg1 ;
47166   Dali::BaseHandle *argp1 ;
47167   Dali::FrameBufferImage result;
47168
47169   argp1 = (Dali::BaseHandle *)jarg1;
47170   if (!argp1) {
47171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47172     return 0;
47173   }
47174   arg1 = *argp1;
47175   {
47176     try {
47177       result = Dali::FrameBufferImage::DownCast(arg1);
47178     } catch (std::out_of_range& e) {
47179       {
47180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (std::exception& e) {
47183       {
47184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (Dali::DaliException e) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196
47197   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47198   return jresult;
47199 }
47200
47201
47202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47203   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47204
47205   arg1 = (Dali::FrameBufferImage *)jarg1;
47206   {
47207     try {
47208       delete arg1;
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47216       };
47217     } catch (Dali::DaliException e) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47224       };
47225     }
47226   }
47227
47228 }
47229
47230
47231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47232   void * jresult ;
47233   Dali::FrameBufferImage *arg1 = 0 ;
47234   Dali::FrameBufferImage *result = 0 ;
47235
47236   arg1 = (Dali::FrameBufferImage *)jarg1;
47237   if (!arg1) {
47238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47239     return 0;
47240   }
47241   {
47242     try {
47243       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47244     } catch (std::out_of_range& e) {
47245       {
47246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47247       };
47248     } catch (std::exception& e) {
47249       {
47250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (Dali::DaliException e) {
47253       {
47254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47255       };
47256     } catch (...) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47259       };
47260     }
47261   }
47262
47263   jresult = (void *)result;
47264   return jresult;
47265 }
47266
47267
47268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47269   void * jresult ;
47270   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47271   Dali::FrameBufferImage *arg2 = 0 ;
47272   Dali::FrameBufferImage *result = 0 ;
47273
47274   arg1 = (Dali::FrameBufferImage *)jarg1;
47275   arg2 = (Dali::FrameBufferImage *)jarg2;
47276   if (!arg2) {
47277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47278     return 0;
47279   }
47280   {
47281     try {
47282       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47283     } catch (std::out_of_range& e) {
47284       {
47285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47286       };
47287     } catch (std::exception& e) {
47288       {
47289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47290       };
47291     } catch (Dali::DaliException e) {
47292       {
47293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47294       };
47295     } catch (...) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47298       };
47299     }
47300   }
47301
47302   jresult = (void *)result;
47303   return jresult;
47304 }
47305
47306
47307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47308   void * jresult ;
47309   Dali::NinePatchImage *result = 0 ;
47310
47311   {
47312     try {
47313       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47314     } catch (std::out_of_range& e) {
47315       {
47316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (std::exception& e) {
47319       {
47320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (Dali::DaliException e) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47329       };
47330     }
47331   }
47332
47333   jresult = (void *)result;
47334   return jresult;
47335 }
47336
47337
47338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47339   void * jresult ;
47340   std::string *arg1 = 0 ;
47341   Dali::NinePatchImage result;
47342
47343   if (!jarg1) {
47344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47345     return 0;
47346   }
47347   std::string arg1_str(jarg1);
47348   arg1 = &arg1_str;
47349   {
47350     try {
47351       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47352     } catch (std::out_of_range& e) {
47353       {
47354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47355       };
47356     } catch (std::exception& e) {
47357       {
47358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47359       };
47360     } catch (Dali::DaliException e) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47363       };
47364     } catch (...) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47367       };
47368     }
47369   }
47370
47371   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47372
47373   //argout typemap for const std::string&
47374
47375   return jresult;
47376 }
47377
47378
47379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47380   void * jresult ;
47381   Dali::BaseHandle arg1 ;
47382   Dali::BaseHandle *argp1 ;
47383   Dali::NinePatchImage result;
47384
47385   argp1 = (Dali::BaseHandle *)jarg1;
47386   if (!argp1) {
47387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47388     return 0;
47389   }
47390   arg1 = *argp1;
47391   {
47392     try {
47393       result = Dali::NinePatchImage::DownCast(arg1);
47394     } catch (std::out_of_range& e) {
47395       {
47396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (std::exception& e) {
47399       {
47400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47401       };
47402     } catch (Dali::DaliException e) {
47403       {
47404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47405       };
47406     } catch (...) {
47407       {
47408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47409       };
47410     }
47411   }
47412
47413   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47414   return jresult;
47415 }
47416
47417
47418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47419   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47420
47421   arg1 = (Dali::NinePatchImage *)jarg1;
47422   {
47423     try {
47424       delete arg1;
47425     } catch (std::out_of_range& e) {
47426       {
47427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47428       };
47429     } catch (std::exception& e) {
47430       {
47431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47432       };
47433     } catch (Dali::DaliException e) {
47434       {
47435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47436       };
47437     } catch (...) {
47438       {
47439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47440       };
47441     }
47442   }
47443
47444 }
47445
47446
47447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47448   void * jresult ;
47449   Dali::NinePatchImage *arg1 = 0 ;
47450   Dali::NinePatchImage *result = 0 ;
47451
47452   arg1 = (Dali::NinePatchImage *)jarg1;
47453   if (!arg1) {
47454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47455     return 0;
47456   }
47457   {
47458     try {
47459       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47460     } catch (std::out_of_range& e) {
47461       {
47462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47463       };
47464     } catch (std::exception& e) {
47465       {
47466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47467       };
47468     } catch (Dali::DaliException e) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47471       };
47472     } catch (...) {
47473       {
47474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47475       };
47476     }
47477   }
47478
47479   jresult = (void *)result;
47480   return jresult;
47481 }
47482
47483
47484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47485   void * jresult ;
47486   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47487   Dali::NinePatchImage *arg2 = 0 ;
47488   Dali::NinePatchImage *result = 0 ;
47489
47490   arg1 = (Dali::NinePatchImage *)jarg1;
47491   arg2 = (Dali::NinePatchImage *)jarg2;
47492   if (!arg2) {
47493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47494     return 0;
47495   }
47496   {
47497     try {
47498       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47499     } catch (std::out_of_range& e) {
47500       {
47501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47502       };
47503     } catch (std::exception& e) {
47504       {
47505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47506       };
47507     } catch (Dali::DaliException e) {
47508       {
47509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47510       };
47511     } catch (...) {
47512       {
47513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47514       };
47515     }
47516   }
47517
47518   jresult = (void *)result;
47519   return jresult;
47520 }
47521
47522
47523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47524   void * jresult ;
47525   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47526   Dali::Vector4 result;
47527
47528   arg1 = (Dali::NinePatchImage *)jarg1;
47529   {
47530     try {
47531       result = (arg1)->GetStretchBorders();
47532     } catch (std::out_of_range& e) {
47533       {
47534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47535       };
47536     } catch (std::exception& e) {
47537       {
47538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47539       };
47540     } catch (Dali::DaliException e) {
47541       {
47542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47543       };
47544     } catch (...) {
47545       {
47546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47547       };
47548     }
47549   }
47550
47551   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47557   void * jresult ;
47558   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47559   Dali::NinePatchImage::StretchRanges *result = 0 ;
47560
47561   arg1 = (Dali::NinePatchImage *)jarg1;
47562   {
47563     try {
47564       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (Dali::DaliException e) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47576       };
47577     } catch (...) {
47578       {
47579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47580       };
47581     }
47582   }
47583
47584   jresult = (void *)result;
47585   return jresult;
47586 }
47587
47588
47589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47590   void * jresult ;
47591   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47592   Dali::NinePatchImage::StretchRanges *result = 0 ;
47593
47594   arg1 = (Dali::NinePatchImage *)jarg1;
47595   {
47596     try {
47597       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47598     } catch (std::out_of_range& e) {
47599       {
47600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47601       };
47602     } catch (std::exception& e) {
47603       {
47604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47605       };
47606     } catch (Dali::DaliException e) {
47607       {
47608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47609       };
47610     } catch (...) {
47611       {
47612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47613       };
47614     }
47615   }
47616
47617   jresult = (void *)result;
47618   return jresult;
47619 }
47620
47621
47622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47623   void * jresult ;
47624   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47625   Dali::Rect< int > result;
47626
47627   arg1 = (Dali::NinePatchImage *)jarg1;
47628   {
47629     try {
47630       result = (arg1)->GetChildRectangle();
47631     } catch (std::out_of_range& e) {
47632       {
47633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47634       };
47635     } catch (std::exception& e) {
47636       {
47637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (Dali::DaliException e) {
47640       {
47641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47642       };
47643     } catch (...) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47646       };
47647     }
47648   }
47649
47650   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47651   return jresult;
47652 }
47653
47654
47655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47656   void * jresult ;
47657   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47658   Dali::BufferImage result;
47659
47660   arg1 = (Dali::NinePatchImage *)jarg1;
47661   {
47662     try {
47663       result = (arg1)->CreateCroppedBufferImage();
47664     } catch (std::out_of_range& e) {
47665       {
47666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47667       };
47668     } catch (std::exception& e) {
47669       {
47670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47671       };
47672     } catch (Dali::DaliException e) {
47673       {
47674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47675       };
47676     } catch (...) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47679       };
47680     }
47681   }
47682
47683   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47684   return jresult;
47685 }
47686
47687
47688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47689   unsigned int jresult ;
47690   std::string *arg1 = 0 ;
47691   bool result;
47692
47693   if (!jarg1) {
47694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47695     return 0;
47696   }
47697   std::string arg1_str(jarg1);
47698   arg1 = &arg1_str;
47699   {
47700     try {
47701       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47702     } catch (std::out_of_range& e) {
47703       {
47704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47705       };
47706     } catch (std::exception& e) {
47707       {
47708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47709       };
47710     } catch (Dali::DaliException e) {
47711       {
47712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47713       };
47714     } catch (...) {
47715       {
47716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47717       };
47718     }
47719   }
47720
47721   jresult = result;
47722
47723   //argout typemap for const std::string&
47724
47725   return jresult;
47726 }
47727
47728
47729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47730   int jresult ;
47731   int result;
47732
47733   result = (int)Dali::CameraActor::Property::TYPE;
47734   jresult = (int)result;
47735   return jresult;
47736 }
47737
47738
47739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47740   int jresult ;
47741   int result;
47742
47743   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47744   jresult = (int)result;
47745   return jresult;
47746 }
47747
47748
47749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47750   int jresult ;
47751   int result;
47752
47753   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47754   jresult = (int)result;
47755   return jresult;
47756 }
47757
47758
47759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47760   int jresult ;
47761   int result;
47762
47763   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47764   jresult = (int)result;
47765   return jresult;
47766 }
47767
47768
47769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47770   int jresult ;
47771   int result;
47772
47773   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47774   jresult = (int)result;
47775   return jresult;
47776 }
47777
47778
47779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47780   int jresult ;
47781   int result;
47782
47783   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47784   jresult = (int)result;
47785   return jresult;
47786 }
47787
47788
47789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47790   int jresult ;
47791   int result;
47792
47793   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47794   jresult = (int)result;
47795   return jresult;
47796 }
47797
47798
47799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47800   int jresult ;
47801   int result;
47802
47803   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47804   jresult = (int)result;
47805   return jresult;
47806 }
47807
47808
47809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47810   int jresult ;
47811   int result;
47812
47813   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47814   jresult = (int)result;
47815   return jresult;
47816 }
47817
47818
47819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47820   int jresult ;
47821   int result;
47822
47823   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47824   jresult = (int)result;
47825   return jresult;
47826 }
47827
47828
47829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47830   int jresult ;
47831   int result;
47832
47833   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
47834   jresult = (int)result;
47835   return jresult;
47836 }
47837
47838
47839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
47840   int jresult ;
47841   int result;
47842
47843   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
47844   jresult = (int)result;
47845   return jresult;
47846 }
47847
47848
47849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
47850   int jresult ;
47851   int result;
47852
47853   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
47854   jresult = (int)result;
47855   return jresult;
47856 }
47857
47858
47859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
47860   int jresult ;
47861   int result;
47862
47863   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
47864   jresult = (int)result;
47865   return jresult;
47866 }
47867
47868
47869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
47870   void * jresult ;
47871   Dali::CameraActor::Property *result = 0 ;
47872
47873   {
47874     try {
47875       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (Dali::DaliException e) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47891       };
47892     }
47893   }
47894
47895   jresult = (void *)result;
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
47901   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
47902
47903   arg1 = (Dali::CameraActor::Property *)jarg1;
47904   {
47905     try {
47906       delete arg1;
47907     } catch (std::out_of_range& e) {
47908       {
47909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47910       };
47911     } catch (std::exception& e) {
47912       {
47913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47914       };
47915     } catch (Dali::DaliException e) {
47916       {
47917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47918       };
47919     } catch (...) {
47920       {
47921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47922       };
47923     }
47924   }
47925
47926 }
47927
47928
47929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
47930   void * jresult ;
47931   Dali::CameraActor *result = 0 ;
47932
47933   {
47934     try {
47935       result = (Dali::CameraActor *)new Dali::CameraActor();
47936     } catch (std::out_of_range& e) {
47937       {
47938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47939       };
47940     } catch (std::exception& e) {
47941       {
47942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47943       };
47944     } catch (Dali::DaliException e) {
47945       {
47946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47947       };
47948     } catch (...) {
47949       {
47950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47951       };
47952     }
47953   }
47954
47955   jresult = (void *)result;
47956   return jresult;
47957 }
47958
47959
47960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
47961   void * jresult ;
47962   Dali::CameraActor result;
47963
47964   {
47965     try {
47966       result = Dali::CameraActor::New();
47967     } catch (std::out_of_range& e) {
47968       {
47969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47970       };
47971     } catch (std::exception& e) {
47972       {
47973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47974       };
47975     } catch (Dali::DaliException e) {
47976       {
47977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47978       };
47979     } catch (...) {
47980       {
47981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47982       };
47983     }
47984   }
47985
47986   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
47987   return jresult;
47988 }
47989
47990
47991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
47992   void * jresult ;
47993   Dali::Size *arg1 = 0 ;
47994   Dali::CameraActor result;
47995
47996   arg1 = (Dali::Size *)jarg1;
47997   if (!arg1) {
47998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47999     return 0;
48000   }
48001   {
48002     try {
48003       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48004     } catch (std::out_of_range& e) {
48005       {
48006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48007       };
48008     } catch (std::exception& e) {
48009       {
48010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48011       };
48012     } catch (Dali::DaliException e) {
48013       {
48014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48015       };
48016     } catch (...) {
48017       {
48018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48019       };
48020     }
48021   }
48022
48023   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48029   void * jresult ;
48030   Dali::BaseHandle arg1 ;
48031   Dali::BaseHandle *argp1 ;
48032   Dali::CameraActor result;
48033
48034   argp1 = (Dali::BaseHandle *)jarg1;
48035   if (!argp1) {
48036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48037     return 0;
48038   }
48039   arg1 = *argp1;
48040   {
48041     try {
48042       result = Dali::CameraActor::DownCast(arg1);
48043     } catch (std::out_of_range& e) {
48044       {
48045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48046       };
48047     } catch (std::exception& e) {
48048       {
48049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48050       };
48051     } catch (Dali::DaliException e) {
48052       {
48053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48054       };
48055     } catch (...) {
48056       {
48057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48058       };
48059     }
48060   }
48061
48062   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48063   return jresult;
48064 }
48065
48066
48067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48068   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48069
48070   arg1 = (Dali::CameraActor *)jarg1;
48071   {
48072     try {
48073       delete arg1;
48074     } catch (std::out_of_range& e) {
48075       {
48076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48077       };
48078     } catch (std::exception& e) {
48079       {
48080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48081       };
48082     } catch (Dali::DaliException e) {
48083       {
48084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48085       };
48086     } catch (...) {
48087       {
48088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48089       };
48090     }
48091   }
48092
48093 }
48094
48095
48096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48097   void * jresult ;
48098   Dali::CameraActor *arg1 = 0 ;
48099   Dali::CameraActor *result = 0 ;
48100
48101   arg1 = (Dali::CameraActor *)jarg1;
48102   if (!arg1) {
48103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48104     return 0;
48105   }
48106   {
48107     try {
48108       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48109     } catch (std::out_of_range& e) {
48110       {
48111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48112       };
48113     } catch (std::exception& e) {
48114       {
48115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48116       };
48117     } catch (Dali::DaliException e) {
48118       {
48119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48120       };
48121     } catch (...) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48124       };
48125     }
48126   }
48127
48128   jresult = (void *)result;
48129   return jresult;
48130 }
48131
48132
48133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48134   void * jresult ;
48135   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48136   Dali::CameraActor *arg2 = 0 ;
48137   Dali::CameraActor *result = 0 ;
48138
48139   arg1 = (Dali::CameraActor *)jarg1;
48140   arg2 = (Dali::CameraActor *)jarg2;
48141   if (!arg2) {
48142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48143     return 0;
48144   }
48145   {
48146     try {
48147       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48148     } catch (std::out_of_range& e) {
48149       {
48150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48151       };
48152     } catch (std::exception& e) {
48153       {
48154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48155       };
48156     } catch (Dali::DaliException e) {
48157       {
48158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48163       };
48164     }
48165   }
48166
48167   jresult = (void *)result;
48168   return jresult;
48169 }
48170
48171
48172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48173   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48174   Dali::Camera::Type arg2 ;
48175
48176   arg1 = (Dali::CameraActor *)jarg1;
48177   arg2 = (Dali::Camera::Type)jarg2;
48178   {
48179     try {
48180       (arg1)->SetType(arg2);
48181     } catch (std::out_of_range& e) {
48182       {
48183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48184       };
48185     } catch (std::exception& e) {
48186       {
48187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48188       };
48189     } catch (Dali::DaliException e) {
48190       {
48191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48192       };
48193     } catch (...) {
48194       {
48195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48196       };
48197     }
48198   }
48199
48200 }
48201
48202
48203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48204   int jresult ;
48205   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48206   Dali::Camera::Type result;
48207
48208   arg1 = (Dali::CameraActor *)jarg1;
48209   {
48210     try {
48211       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48212     } catch (std::out_of_range& e) {
48213       {
48214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48215       };
48216     } catch (std::exception& e) {
48217       {
48218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (Dali::DaliException e) {
48221       {
48222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48223       };
48224     } catch (...) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48227       };
48228     }
48229   }
48230
48231   jresult = (int)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48237   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48238   Dali::Camera::ProjectionMode arg2 ;
48239
48240   arg1 = (Dali::CameraActor *)jarg1;
48241   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48242   {
48243     try {
48244       (arg1)->SetProjectionMode(arg2);
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (Dali::DaliException e) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48256       };
48257     } catch (...) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48260       };
48261     }
48262   }
48263
48264 }
48265
48266
48267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48268   int jresult ;
48269   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48270   Dali::Camera::ProjectionMode result;
48271
48272   arg1 = (Dali::CameraActor *)jarg1;
48273   {
48274     try {
48275       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48276     } catch (std::out_of_range& e) {
48277       {
48278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48279       };
48280     } catch (std::exception& e) {
48281       {
48282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (Dali::DaliException e) {
48285       {
48286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48287       };
48288     } catch (...) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48291       };
48292     }
48293   }
48294
48295   jresult = (int)result;
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48301   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48302   float arg2 ;
48303
48304   arg1 = (Dali::CameraActor *)jarg1;
48305   arg2 = (float)jarg2;
48306   {
48307     try {
48308       (arg1)->SetFieldOfView(arg2);
48309     } catch (std::out_of_range& e) {
48310       {
48311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48312       };
48313     } catch (std::exception& e) {
48314       {
48315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48316       };
48317     } catch (Dali::DaliException e) {
48318       {
48319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48320       };
48321     } catch (...) {
48322       {
48323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48324       };
48325     }
48326   }
48327
48328 }
48329
48330
48331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48332   float jresult ;
48333   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48334   float result;
48335
48336   arg1 = (Dali::CameraActor *)jarg1;
48337   {
48338     try {
48339       result = (float)(arg1)->GetFieldOfView();
48340     } catch (std::out_of_range& e) {
48341       {
48342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48343       };
48344     } catch (std::exception& e) {
48345       {
48346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (Dali::DaliException e) {
48349       {
48350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48351       };
48352     } catch (...) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48355       };
48356     }
48357   }
48358
48359   jresult = result;
48360   return jresult;
48361 }
48362
48363
48364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48365   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48366   float arg2 ;
48367
48368   arg1 = (Dali::CameraActor *)jarg1;
48369   arg2 = (float)jarg2;
48370   {
48371     try {
48372       (arg1)->SetAspectRatio(arg2);
48373     } catch (std::out_of_range& e) {
48374       {
48375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48376       };
48377     } catch (std::exception& e) {
48378       {
48379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48380       };
48381     } catch (Dali::DaliException e) {
48382       {
48383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48384       };
48385     } catch (...) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48388       };
48389     }
48390   }
48391
48392 }
48393
48394
48395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48396   float jresult ;
48397   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48398   float result;
48399
48400   arg1 = (Dali::CameraActor *)jarg1;
48401   {
48402     try {
48403       result = (float)(arg1)->GetAspectRatio();
48404     } catch (std::out_of_range& e) {
48405       {
48406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48407       };
48408     } catch (std::exception& e) {
48409       {
48410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48411       };
48412     } catch (Dali::DaliException e) {
48413       {
48414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48415       };
48416     } catch (...) {
48417       {
48418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48419       };
48420     }
48421   }
48422
48423   jresult = result;
48424   return jresult;
48425 }
48426
48427
48428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48429   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48430   float arg2 ;
48431
48432   arg1 = (Dali::CameraActor *)jarg1;
48433   arg2 = (float)jarg2;
48434   {
48435     try {
48436       (arg1)->SetNearClippingPlane(arg2);
48437     } catch (std::out_of_range& e) {
48438       {
48439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48440       };
48441     } catch (std::exception& e) {
48442       {
48443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48444       };
48445     } catch (Dali::DaliException e) {
48446       {
48447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48448       };
48449     } catch (...) {
48450       {
48451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48452       };
48453     }
48454   }
48455
48456 }
48457
48458
48459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48460   float jresult ;
48461   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48462   float result;
48463
48464   arg1 = (Dali::CameraActor *)jarg1;
48465   {
48466     try {
48467       result = (float)(arg1)->GetNearClippingPlane();
48468     } catch (std::out_of_range& e) {
48469       {
48470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48471       };
48472     } catch (std::exception& e) {
48473       {
48474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48475       };
48476     } catch (Dali::DaliException e) {
48477       {
48478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48479       };
48480     } catch (...) {
48481       {
48482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48483       };
48484     }
48485   }
48486
48487   jresult = result;
48488   return jresult;
48489 }
48490
48491
48492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48493   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48494   float arg2 ;
48495
48496   arg1 = (Dali::CameraActor *)jarg1;
48497   arg2 = (float)jarg2;
48498   {
48499     try {
48500       (arg1)->SetFarClippingPlane(arg2);
48501     } catch (std::out_of_range& e) {
48502       {
48503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48504       };
48505     } catch (std::exception& e) {
48506       {
48507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48508       };
48509     } catch (Dali::DaliException e) {
48510       {
48511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48512       };
48513     } catch (...) {
48514       {
48515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48516       };
48517     }
48518   }
48519
48520 }
48521
48522
48523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48524   float jresult ;
48525   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48526   float result;
48527
48528   arg1 = (Dali::CameraActor *)jarg1;
48529   {
48530     try {
48531       result = (float)(arg1)->GetFarClippingPlane();
48532     } catch (std::out_of_range& e) {
48533       {
48534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48535       };
48536     } catch (std::exception& e) {
48537       {
48538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48539       };
48540     } catch (Dali::DaliException e) {
48541       {
48542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48543       };
48544     } catch (...) {
48545       {
48546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48547       };
48548     }
48549   }
48550
48551   jresult = result;
48552   return jresult;
48553 }
48554
48555
48556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48557   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48558   Dali::Vector3 *arg2 = 0 ;
48559
48560   arg1 = (Dali::CameraActor *)jarg1;
48561   arg2 = (Dali::Vector3 *)jarg2;
48562   if (!arg2) {
48563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48564     return ;
48565   }
48566   {
48567     try {
48568       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48569     } catch (std::out_of_range& e) {
48570       {
48571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48572       };
48573     } catch (std::exception& e) {
48574       {
48575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48576       };
48577     } catch (Dali::DaliException e) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48580       };
48581     } catch (...) {
48582       {
48583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48584       };
48585     }
48586   }
48587
48588 }
48589
48590
48591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48592   void * jresult ;
48593   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48594   Dali::Vector3 result;
48595
48596   arg1 = (Dali::CameraActor *)jarg1;
48597   {
48598     try {
48599       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48600     } catch (std::out_of_range& e) {
48601       {
48602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48603       };
48604     } catch (std::exception& e) {
48605       {
48606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48607       };
48608     } catch (Dali::DaliException e) {
48609       {
48610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48611       };
48612     } catch (...) {
48613       {
48614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48615       };
48616     }
48617   }
48618
48619   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48620   return jresult;
48621 }
48622
48623
48624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48625   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48626   bool arg2 ;
48627
48628   arg1 = (Dali::CameraActor *)jarg1;
48629   arg2 = jarg2 ? true : false;
48630   {
48631     try {
48632       (arg1)->SetInvertYAxis(arg2);
48633     } catch (std::out_of_range& e) {
48634       {
48635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48636       };
48637     } catch (std::exception& e) {
48638       {
48639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48640       };
48641     } catch (Dali::DaliException e) {
48642       {
48643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48644       };
48645     } catch (...) {
48646       {
48647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48648       };
48649     }
48650   }
48651
48652 }
48653
48654
48655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48656   unsigned int jresult ;
48657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48658   bool result;
48659
48660   arg1 = (Dali::CameraActor *)jarg1;
48661   {
48662     try {
48663       result = (bool)(arg1)->GetInvertYAxis();
48664     } catch (std::out_of_range& e) {
48665       {
48666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48667       };
48668     } catch (std::exception& e) {
48669       {
48670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48671       };
48672     } catch (Dali::DaliException e) {
48673       {
48674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48675       };
48676     } catch (...) {
48677       {
48678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48679       };
48680     }
48681   }
48682
48683   jresult = result;
48684   return jresult;
48685 }
48686
48687
48688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48689   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48690   Dali::Size *arg2 = 0 ;
48691
48692   arg1 = (Dali::CameraActor *)jarg1;
48693   arg2 = (Dali::Size *)jarg2;
48694   if (!arg2) {
48695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48696     return ;
48697   }
48698   {
48699     try {
48700       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48701     } catch (std::out_of_range& e) {
48702       {
48703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (std::exception& e) {
48706       {
48707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48708       };
48709     } catch (Dali::DaliException e) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48712       };
48713     } catch (...) {
48714       {
48715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48716       };
48717     }
48718   }
48719
48720 }
48721
48722
48723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48724   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48725   Dali::Size *arg2 = 0 ;
48726
48727   arg1 = (Dali::CameraActor *)jarg1;
48728   arg2 = (Dali::Size *)jarg2;
48729   if (!arg2) {
48730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48731     return ;
48732   }
48733   {
48734     try {
48735       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48736     } catch (std::out_of_range& e) {
48737       {
48738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48739       };
48740     } catch (std::exception& e) {
48741       {
48742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48743       };
48744     } catch (Dali::DaliException e) {
48745       {
48746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48747       };
48748     } catch (...) {
48749       {
48750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48751       };
48752     }
48753   }
48754
48755 }
48756
48757
48758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48759   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48760   float arg2 ;
48761   float arg3 ;
48762   float arg4 ;
48763   float arg5 ;
48764   float arg6 ;
48765   float arg7 ;
48766
48767   arg1 = (Dali::CameraActor *)jarg1;
48768   arg2 = (float)jarg2;
48769   arg3 = (float)jarg3;
48770   arg4 = (float)jarg4;
48771   arg5 = (float)jarg5;
48772   arg6 = (float)jarg6;
48773   arg7 = (float)jarg7;
48774   {
48775     try {
48776       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (Dali::DaliException e) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48788       };
48789     } catch (...) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48792       };
48793     }
48794   }
48795
48796 }
48797
48798
48799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48800   void * jresult ;
48801   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48802
48803   {
48804     try {
48805       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48806     } catch (std::out_of_range& e) {
48807       {
48808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48809       };
48810     } catch (std::exception& e) {
48811       {
48812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48813       };
48814     } catch (Dali::DaliException e) {
48815       {
48816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48817       };
48818     } catch (...) {
48819       {
48820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48821       };
48822     }
48823   }
48824
48825   jresult = (void *)result;
48826   return jresult;
48827 }
48828
48829
48830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
48831   void * jresult ;
48832   std::string arg1 ;
48833   Dali::Property::Value arg2 ;
48834   Dali::Property::Value *argp2 ;
48835   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48836
48837   if (!jarg1) {
48838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48839     return 0;
48840   }
48841   (&arg1)->assign(jarg1);
48842   argp2 = (Dali::Property::Value *)jarg2;
48843   if (!argp2) {
48844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
48845     return 0;
48846   }
48847   arg2 = *argp2;
48848   {
48849     try {
48850       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
48851     } catch (std::out_of_range& e) {
48852       {
48853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48854       };
48855     } catch (std::exception& e) {
48856       {
48857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48858       };
48859     } catch (Dali::DaliException e) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48862       };
48863     } catch (...) {
48864       {
48865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48866       };
48867     }
48868   }
48869
48870   jresult = (void *)result;
48871   return jresult;
48872 }
48873
48874
48875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
48876   void * jresult ;
48877   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
48878   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48879
48880   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48881   if (!arg1) {
48882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
48883     return 0;
48884   }
48885   {
48886     try {
48887       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);
48888     } catch (std::out_of_range& e) {
48889       {
48890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48891       };
48892     } catch (std::exception& e) {
48893       {
48894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48895       };
48896     } catch (Dali::DaliException e) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48899       };
48900     } catch (...) {
48901       {
48902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48903       };
48904     }
48905   }
48906
48907   jresult = (void *)result;
48908   return jresult;
48909 }
48910
48911
48912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
48913   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48914   std::string *arg2 = 0 ;
48915
48916   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48917   if (!jarg2) {
48918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48919     return ;
48920   }
48921   std::string arg2_str(jarg2);
48922   arg2 = &arg2_str;
48923   if (arg1) (arg1)->first = *arg2;
48924
48925   //argout typemap for const std::string&
48926
48927 }
48928
48929
48930 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
48931   char * jresult ;
48932   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48933   std::string *result = 0 ;
48934
48935   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48936   result = (std::string *) & ((arg1)->first);
48937   jresult = SWIG_csharp_string_callback(result->c_str());
48938   return jresult;
48939 }
48940
48941
48942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
48943   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48944   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
48945
48946   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48947   arg2 = (Dali::Property::Value *)jarg2;
48948   if (arg1) (arg1)->second = *arg2;
48949 }
48950
48951
48952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
48953   void * jresult ;
48954   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48955   Dali::Property::Value *result = 0 ;
48956
48957   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48958   result = (Dali::Property::Value *)& ((arg1)->second);
48959   jresult = (void *)result;
48960   return jresult;
48961 }
48962
48963
48964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
48965   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48966
48967   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48968   {
48969     try {
48970       delete arg1;
48971     } catch (std::out_of_range& e) {
48972       {
48973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48974       };
48975     } catch (std::exception& e) {
48976       {
48977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48978       };
48979     } catch (Dali::DaliException e) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48982       };
48983     } catch (...) {
48984       {
48985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48986       };
48987     }
48988   }
48989
48990 }
48991
48992
48993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
48994   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48995
48996   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48997   {
48998     try {
48999       (arg1)->clear();
49000     } catch (std::out_of_range& e) {
49001       {
49002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49003       };
49004     } catch (std::exception& e) {
49005       {
49006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49007       };
49008     } catch (Dali::DaliException e) {
49009       {
49010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49011       };
49012     } catch (...) {
49013       {
49014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49015       };
49016     }
49017   }
49018
49019 }
49020
49021
49022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49023   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49024   Dali::TouchPoint *arg2 = 0 ;
49025
49026   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49027   arg2 = (Dali::TouchPoint *)jarg2;
49028   if (!arg2) {
49029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49030     return ;
49031   }
49032   {
49033     try {
49034       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49035     } catch (std::out_of_range& e) {
49036       {
49037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49038       };
49039     } catch (std::exception& e) {
49040       {
49041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49042       };
49043     } catch (Dali::DaliException e) {
49044       {
49045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49046       };
49047     } catch (...) {
49048       {
49049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49050       };
49051     }
49052   }
49053
49054 }
49055
49056
49057 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49058   unsigned long jresult ;
49059   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49060   std::vector< Dali::TouchPoint >::size_type result;
49061
49062   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49063   {
49064     try {
49065       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49073       };
49074     } catch (Dali::DaliException e) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49077       };
49078     } catch (...) {
49079       {
49080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49081       };
49082     }
49083   }
49084
49085   jresult = (unsigned long)result;
49086   return jresult;
49087 }
49088
49089
49090 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49091   unsigned long jresult ;
49092   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49093   std::vector< Dali::TouchPoint >::size_type result;
49094
49095   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49096   {
49097     try {
49098       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49099     } catch (std::out_of_range& e) {
49100       {
49101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49102       };
49103     } catch (std::exception& e) {
49104       {
49105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49106       };
49107     } catch (Dali::DaliException e) {
49108       {
49109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49110       };
49111     } catch (...) {
49112       {
49113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49114       };
49115     }
49116   }
49117
49118   jresult = (unsigned long)result;
49119   return jresult;
49120 }
49121
49122
49123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49124   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49125   std::vector< Dali::TouchPoint >::size_type arg2 ;
49126
49127   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49128   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49129   {
49130     try {
49131       (arg1)->reserve(arg2);
49132     } catch (std::out_of_range& e) {
49133       {
49134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49135       };
49136     } catch (std::exception& e) {
49137       {
49138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49139       };
49140     } catch (Dali::DaliException e) {
49141       {
49142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49143       };
49144     } catch (...) {
49145       {
49146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49147       };
49148     }
49149   }
49150
49151 }
49152
49153
49154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49155   void * jresult ;
49156   std::vector< Dali::TouchPoint > *result = 0 ;
49157
49158   {
49159     try {
49160       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49161     } catch (std::out_of_range& e) {
49162       {
49163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49164       };
49165     } catch (std::exception& e) {
49166       {
49167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49168       };
49169     } catch (Dali::DaliException e) {
49170       {
49171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49172       };
49173     } catch (...) {
49174       {
49175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49176       };
49177     }
49178   }
49179
49180   jresult = (void *)result;
49181   return jresult;
49182 }
49183
49184
49185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49186   void * jresult ;
49187   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49188   std::vector< Dali::TouchPoint > *result = 0 ;
49189
49190   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49191   if (!arg1) {
49192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49193     return 0;
49194   }
49195   {
49196     try {
49197       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49198     } catch (std::out_of_range& e) {
49199       {
49200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49201       };
49202     } catch (std::exception& e) {
49203       {
49204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49205       };
49206     } catch (Dali::DaliException e) {
49207       {
49208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49209       };
49210     } catch (...) {
49211       {
49212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49213       };
49214     }
49215   }
49216
49217   jresult = (void *)result;
49218   return jresult;
49219 }
49220
49221
49222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49223   void * jresult ;
49224   int arg1 ;
49225   std::vector< Dali::TouchPoint > *result = 0 ;
49226
49227   arg1 = (int)jarg1;
49228   {
49229     try {
49230       try {
49231         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49232       }
49233       catch(std::out_of_range &_e) {
49234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49235         return 0;
49236       }
49237
49238     } catch (std::out_of_range& e) {
49239       {
49240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49241       };
49242     } catch (std::exception& e) {
49243       {
49244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49245       };
49246     } catch (Dali::DaliException e) {
49247       {
49248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49249       };
49250     } catch (...) {
49251       {
49252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49253       };
49254     }
49255   }
49256
49257   jresult = (void *)result;
49258   return jresult;
49259 }
49260
49261
49262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49263   void * jresult ;
49264   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49265   int arg2 ;
49266   SwigValueWrapper< Dali::TouchPoint > result;
49267
49268   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49269   arg2 = (int)jarg2;
49270   {
49271     try {
49272       try {
49273         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49274       }
49275       catch(std::out_of_range &_e) {
49276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49277         return 0;
49278       }
49279
49280     } catch (std::out_of_range& e) {
49281       {
49282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (std::exception& e) {
49285       {
49286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49287       };
49288     } catch (Dali::DaliException e) {
49289       {
49290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49291       };
49292     } catch (...) {
49293       {
49294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49295       };
49296     }
49297   }
49298
49299   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49300   return jresult;
49301 }
49302
49303
49304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49305   void * jresult ;
49306   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49307   int arg2 ;
49308   Dali::TouchPoint *result = 0 ;
49309
49310   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49311   arg2 = (int)jarg2;
49312   {
49313     try {
49314       try {
49315         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49316       }
49317       catch(std::out_of_range &_e) {
49318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49319         return 0;
49320       }
49321
49322     } catch (std::out_of_range& e) {
49323       {
49324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49325       };
49326     } catch (std::exception& e) {
49327       {
49328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49329       };
49330     } catch (Dali::DaliException e) {
49331       {
49332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49333       };
49334     } catch (...) {
49335       {
49336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49337       };
49338     }
49339   }
49340
49341   jresult = (void *)result;
49342   return jresult;
49343 }
49344
49345
49346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49347   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49348   int arg2 ;
49349   Dali::TouchPoint *arg3 = 0 ;
49350
49351   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49352   arg2 = (int)jarg2;
49353   arg3 = (Dali::TouchPoint *)jarg3;
49354   if (!arg3) {
49355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49356     return ;
49357   }
49358   {
49359     try {
49360       try {
49361         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49362       }
49363       catch(std::out_of_range &_e) {
49364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49365         return ;
49366       }
49367
49368     } catch (std::out_of_range& e) {
49369       {
49370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49371       };
49372     } catch (std::exception& e) {
49373       {
49374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49375       };
49376     } catch (Dali::DaliException e) {
49377       {
49378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49379       };
49380     } catch (...) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49383       };
49384     }
49385   }
49386
49387 }
49388
49389
49390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49391   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49392   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49393
49394   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49395   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49396   if (!arg2) {
49397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49398     return ;
49399   }
49400   {
49401     try {
49402       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49403     } catch (std::out_of_range& e) {
49404       {
49405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49406       };
49407     } catch (std::exception& e) {
49408       {
49409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49410       };
49411     } catch (Dali::DaliException e) {
49412       {
49413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49414       };
49415     } catch (...) {
49416       {
49417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49418       };
49419     }
49420   }
49421
49422 }
49423
49424
49425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49426   void * jresult ;
49427   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49428   int arg2 ;
49429   int arg3 ;
49430   std::vector< Dali::TouchPoint > *result = 0 ;
49431
49432   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49433   arg2 = (int)jarg2;
49434   arg3 = (int)jarg3;
49435   {
49436     try {
49437       try {
49438         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49439       }
49440       catch(std::out_of_range &_e) {
49441         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49442         return 0;
49443       }
49444       catch(std::invalid_argument &_e) {
49445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49446         return 0;
49447       }
49448
49449     } catch (std::out_of_range& e) {
49450       {
49451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49452       };
49453     } catch (std::exception& e) {
49454       {
49455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49456       };
49457     } catch (Dali::DaliException e) {
49458       {
49459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49460       };
49461     } catch (...) {
49462       {
49463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49464       };
49465     }
49466   }
49467
49468   jresult = (void *)result;
49469   return jresult;
49470 }
49471
49472
49473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49474   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49475   int arg2 ;
49476   Dali::TouchPoint *arg3 = 0 ;
49477
49478   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49479   arg2 = (int)jarg2;
49480   arg3 = (Dali::TouchPoint *)jarg3;
49481   if (!arg3) {
49482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49483     return ;
49484   }
49485   {
49486     try {
49487       try {
49488         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49489       }
49490       catch(std::out_of_range &_e) {
49491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49492         return ;
49493       }
49494
49495     } catch (std::out_of_range& e) {
49496       {
49497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49498       };
49499     } catch (std::exception& e) {
49500       {
49501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49502       };
49503     } catch (Dali::DaliException e) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49506       };
49507     } catch (...) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49510       };
49511     }
49512   }
49513
49514 }
49515
49516
49517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49518   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49519   int arg2 ;
49520   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49521
49522   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49523   arg2 = (int)jarg2;
49524   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49525   if (!arg3) {
49526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49527     return ;
49528   }
49529   {
49530     try {
49531       try {
49532         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49533       }
49534       catch(std::out_of_range &_e) {
49535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49536         return ;
49537       }
49538
49539     } catch (std::out_of_range& e) {
49540       {
49541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49542       };
49543     } catch (std::exception& e) {
49544       {
49545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (Dali::DaliException e) {
49548       {
49549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49554       };
49555     }
49556   }
49557
49558 }
49559
49560
49561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49562   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49563   int arg2 ;
49564
49565   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49566   arg2 = (int)jarg2;
49567   {
49568     try {
49569       try {
49570         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49571       }
49572       catch(std::out_of_range &_e) {
49573         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49574         return ;
49575       }
49576
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (Dali::DaliException e) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49588       };
49589     } catch (...) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49592       };
49593     }
49594   }
49595
49596 }
49597
49598
49599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49600   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49601   int arg2 ;
49602   int arg3 ;
49603
49604   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49605   arg2 = (int)jarg2;
49606   arg3 = (int)jarg3;
49607   {
49608     try {
49609       try {
49610         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49611       }
49612       catch(std::out_of_range &_e) {
49613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49614         return ;
49615       }
49616       catch(std::invalid_argument &_e) {
49617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49618         return ;
49619       }
49620
49621     } catch (std::out_of_range& e) {
49622       {
49623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49624       };
49625     } catch (std::exception& e) {
49626       {
49627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49628       };
49629     } catch (Dali::DaliException e) {
49630       {
49631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49632       };
49633     } catch (...) {
49634       {
49635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49636       };
49637     }
49638   }
49639
49640 }
49641
49642
49643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49644   void * jresult ;
49645   Dali::TouchPoint *arg1 = 0 ;
49646   int arg2 ;
49647   std::vector< Dali::TouchPoint > *result = 0 ;
49648
49649   arg1 = (Dali::TouchPoint *)jarg1;
49650   if (!arg1) {
49651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49652     return 0;
49653   }
49654   arg2 = (int)jarg2;
49655   {
49656     try {
49657       try {
49658         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49659       }
49660       catch(std::out_of_range &_e) {
49661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49662         return 0;
49663       }
49664
49665     } catch (std::out_of_range& e) {
49666       {
49667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49668       };
49669     } catch (std::exception& e) {
49670       {
49671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49672       };
49673     } catch (Dali::DaliException e) {
49674       {
49675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49676       };
49677     } catch (...) {
49678       {
49679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49680       };
49681     }
49682   }
49683
49684   jresult = (void *)result;
49685   return jresult;
49686 }
49687
49688
49689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49690   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49691
49692   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49693   {
49694     try {
49695       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49696     } catch (std::out_of_range& e) {
49697       {
49698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49699       };
49700     } catch (std::exception& e) {
49701       {
49702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49703       };
49704     } catch (Dali::DaliException e) {
49705       {
49706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49707       };
49708     } catch (...) {
49709       {
49710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49711       };
49712     }
49713   }
49714
49715 }
49716
49717
49718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49719   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49720   int arg2 ;
49721   int arg3 ;
49722
49723   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49724   arg2 = (int)jarg2;
49725   arg3 = (int)jarg3;
49726   {
49727     try {
49728       try {
49729         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49730       }
49731       catch(std::out_of_range &_e) {
49732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49733         return ;
49734       }
49735       catch(std::invalid_argument &_e) {
49736         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49737         return ;
49738       }
49739
49740     } catch (std::out_of_range& e) {
49741       {
49742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49743       };
49744     } catch (std::exception& e) {
49745       {
49746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49747       };
49748     } catch (Dali::DaliException e) {
49749       {
49750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49751       };
49752     } catch (...) {
49753       {
49754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49755       };
49756     }
49757   }
49758
49759 }
49760
49761
49762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49763   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49764   int arg2 ;
49765   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49766
49767   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49768   arg2 = (int)jarg2;
49769   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49770   if (!arg3) {
49771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49772     return ;
49773   }
49774   {
49775     try {
49776       try {
49777         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49778       }
49779       catch(std::out_of_range &_e) {
49780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49781         return ;
49782       }
49783
49784     } catch (std::out_of_range& e) {
49785       {
49786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49787       };
49788     } catch (std::exception& e) {
49789       {
49790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49791       };
49792     } catch (Dali::DaliException e) {
49793       {
49794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49795       };
49796     } catch (...) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49799       };
49800     }
49801   }
49802
49803 }
49804
49805
49806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49807   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49808
49809   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49810   {
49811     try {
49812       delete arg1;
49813     } catch (std::out_of_range& e) {
49814       {
49815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49816       };
49817     } catch (std::exception& e) {
49818       {
49819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49820       };
49821     } catch (Dali::DaliException e) {
49822       {
49823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49824       };
49825     } catch (...) {
49826       {
49827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49828       };
49829     }
49830   }
49831
49832 }
49833
49834
49835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
49836   void * jresult ;
49837   Dali::Rect< int > *result = 0 ;
49838
49839   {
49840     try {
49841       result = (Dali::Rect< int > *)new Dali::Rect< int >();
49842     } catch (std::out_of_range& e) {
49843       {
49844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49845       };
49846     } catch (std::exception& e) {
49847       {
49848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49849       };
49850     } catch (Dali::DaliException e) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49853       };
49854     } catch (...) {
49855       {
49856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49857       };
49858     }
49859   }
49860
49861   jresult = (void *)result;
49862   return jresult;
49863 }
49864
49865
49866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
49867   void * jresult ;
49868   int arg1 ;
49869   int arg2 ;
49870   int arg3 ;
49871   int arg4 ;
49872   Dali::Rect< int > *result = 0 ;
49873
49874   arg1 = (int)jarg1;
49875   arg2 = (int)jarg2;
49876   arg3 = (int)jarg3;
49877   arg4 = (int)jarg4;
49878   {
49879     try {
49880       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
49881     } catch (std::out_of_range& e) {
49882       {
49883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49884       };
49885     } catch (std::exception& e) {
49886       {
49887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49888       };
49889     } catch (Dali::DaliException e) {
49890       {
49891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49892       };
49893     } catch (...) {
49894       {
49895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49896       };
49897     }
49898   }
49899
49900   jresult = (void *)result;
49901   return jresult;
49902 }
49903
49904
49905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
49906   void * jresult ;
49907   Dali::Rect< int > *arg1 = 0 ;
49908   Dali::Rect< int > *result = 0 ;
49909
49910   arg1 = (Dali::Rect< int > *)jarg1;
49911   if (!arg1) {
49912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49913     return 0;
49914   }
49915   {
49916     try {
49917       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
49918     } catch (std::out_of_range& e) {
49919       {
49920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49921       };
49922     } catch (std::exception& e) {
49923       {
49924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49925       };
49926     } catch (Dali::DaliException e) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49929       };
49930     } catch (...) {
49931       {
49932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49933       };
49934     }
49935   }
49936
49937   jresult = (void *)result;
49938   return jresult;
49939 }
49940
49941
49942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
49943   void * jresult ;
49944   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49945   Dali::Rect< int > *arg2 = 0 ;
49946   Dali::Rect< int > *result = 0 ;
49947
49948   arg1 = (Dali::Rect< int > *)jarg1;
49949   arg2 = (Dali::Rect< int > *)jarg2;
49950   if (!arg2) {
49951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49952     return 0;
49953   }
49954   {
49955     try {
49956       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49972       };
49973     }
49974   }
49975
49976   jresult = (void *)result;
49977   return jresult;
49978 }
49979
49980
49981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
49982   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49983   int arg2 ;
49984   int arg3 ;
49985   int arg4 ;
49986   int arg5 ;
49987
49988   arg1 = (Dali::Rect< int > *)jarg1;
49989   arg2 = (int)jarg2;
49990   arg3 = (int)jarg3;
49991   arg4 = (int)jarg4;
49992   arg5 = (int)jarg5;
49993   {
49994     try {
49995       (arg1)->Set(arg2,arg3,arg4,arg5);
49996     } catch (std::out_of_range& e) {
49997       {
49998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (std::exception& e) {
50001       {
50002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (Dali::DaliException e) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50007       };
50008     } catch (...) {
50009       {
50010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50011       };
50012     }
50013   }
50014
50015 }
50016
50017
50018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50019   unsigned int jresult ;
50020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50021   bool result;
50022
50023   arg1 = (Dali::Rect< int > *)jarg1;
50024   {
50025     try {
50026       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50027     } catch (std::out_of_range& e) {
50028       {
50029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (std::exception& e) {
50032       {
50033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50034       };
50035     } catch (Dali::DaliException e) {
50036       {
50037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50038       };
50039     } catch (...) {
50040       {
50041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50042       };
50043     }
50044   }
50045
50046   jresult = result;
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50052   int jresult ;
50053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50054   int result;
50055
50056   arg1 = (Dali::Rect< int > *)jarg1;
50057   {
50058     try {
50059       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (Dali::DaliException e) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50075       };
50076     }
50077   }
50078
50079   jresult = result;
50080   return jresult;
50081 }
50082
50083
50084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50085   int jresult ;
50086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50087   int result;
50088
50089   arg1 = (Dali::Rect< int > *)jarg1;
50090   {
50091     try {
50092       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50093     } catch (std::out_of_range& e) {
50094       {
50095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50096       };
50097     } catch (std::exception& e) {
50098       {
50099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50100       };
50101     } catch (Dali::DaliException e) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50104       };
50105     } catch (...) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50108       };
50109     }
50110   }
50111
50112   jresult = result;
50113   return jresult;
50114 }
50115
50116
50117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50118   int jresult ;
50119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50120   int result;
50121
50122   arg1 = (Dali::Rect< int > *)jarg1;
50123   {
50124     try {
50125       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50126     } catch (std::out_of_range& e) {
50127       {
50128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50129       };
50130     } catch (std::exception& e) {
50131       {
50132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50133       };
50134     } catch (Dali::DaliException e) {
50135       {
50136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50137       };
50138     } catch (...) {
50139       {
50140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50141       };
50142     }
50143   }
50144
50145   jresult = result;
50146   return jresult;
50147 }
50148
50149
50150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50151   int jresult ;
50152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50153   int result;
50154
50155   arg1 = (Dali::Rect< int > *)jarg1;
50156   {
50157     try {
50158       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50159     } catch (std::out_of_range& e) {
50160       {
50161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50162       };
50163     } catch (std::exception& e) {
50164       {
50165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50166       };
50167     } catch (Dali::DaliException e) {
50168       {
50169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50170       };
50171     } catch (...) {
50172       {
50173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50174       };
50175     }
50176   }
50177
50178   jresult = result;
50179   return jresult;
50180 }
50181
50182
50183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50184   int jresult ;
50185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50186   int result;
50187
50188   arg1 = (Dali::Rect< int > *)jarg1;
50189   {
50190     try {
50191       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50192     } catch (std::out_of_range& e) {
50193       {
50194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50195       };
50196     } catch (std::exception& e) {
50197       {
50198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50199       };
50200     } catch (Dali::DaliException e) {
50201       {
50202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50203       };
50204     } catch (...) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50207       };
50208     }
50209   }
50210
50211   jresult = result;
50212   return jresult;
50213 }
50214
50215
50216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50217   unsigned int jresult ;
50218   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50219   Dali::Rect< int > *arg2 = 0 ;
50220   bool result;
50221
50222   arg1 = (Dali::Rect< int > *)jarg1;
50223   arg2 = (Dali::Rect< int > *)jarg2;
50224   if (!arg2) {
50225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50226     return 0;
50227   }
50228   {
50229     try {
50230       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50231     } catch (std::out_of_range& e) {
50232       {
50233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50234       };
50235     } catch (std::exception& e) {
50236       {
50237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50238       };
50239     } catch (Dali::DaliException e) {
50240       {
50241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50242       };
50243     } catch (...) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50246       };
50247     }
50248   }
50249
50250   jresult = result;
50251   return jresult;
50252 }
50253
50254
50255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50256   unsigned int jresult ;
50257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50258   Dali::Rect< int > *arg2 = 0 ;
50259   bool result;
50260
50261   arg1 = (Dali::Rect< int > *)jarg1;
50262   arg2 = (Dali::Rect< int > *)jarg2;
50263   if (!arg2) {
50264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50265     return 0;
50266   }
50267   {
50268     try {
50269       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50270     } catch (std::out_of_range& e) {
50271       {
50272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50273       };
50274     } catch (std::exception& e) {
50275       {
50276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50277       };
50278     } catch (Dali::DaliException e) {
50279       {
50280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50281       };
50282     } catch (...) {
50283       {
50284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50285       };
50286     }
50287   }
50288
50289   jresult = result;
50290   return jresult;
50291 }
50292
50293
50294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50295   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50296   int arg2 ;
50297
50298   arg1 = (Dali::Rect< int > *)jarg1;
50299   arg2 = (int)jarg2;
50300   if (arg1) (arg1)->x = arg2;
50301 }
50302
50303
50304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50305   int jresult ;
50306   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50307   int result;
50308
50309   arg1 = (Dali::Rect< int > *)jarg1;
50310   result = (int) ((arg1)->x);
50311   jresult = result;
50312   return jresult;
50313 }
50314
50315
50316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50317   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50318   int arg2 ;
50319
50320   arg1 = (Dali::Rect< int > *)jarg1;
50321   arg2 = (int)jarg2;
50322   if (arg1) (arg1)->left = arg2;
50323 }
50324
50325
50326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50327   int jresult ;
50328   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50329   int result;
50330
50331   arg1 = (Dali::Rect< int > *)jarg1;
50332   result = (int) ((arg1)->left);
50333   jresult = result;
50334   return jresult;
50335 }
50336
50337
50338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50339   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50340   int arg2 ;
50341
50342   arg1 = (Dali::Rect< int > *)jarg1;
50343   arg2 = (int)jarg2;
50344   if (arg1) (arg1)->y = arg2;
50345 }
50346
50347
50348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50349   int jresult ;
50350   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50351   int result;
50352
50353   arg1 = (Dali::Rect< int > *)jarg1;
50354   result = (int) ((arg1)->y);
50355   jresult = result;
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50361   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50362   int arg2 ;
50363
50364   arg1 = (Dali::Rect< int > *)jarg1;
50365   arg2 = (int)jarg2;
50366   if (arg1) (arg1)->right = arg2;
50367 }
50368
50369
50370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50371   int jresult ;
50372   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50373   int result;
50374
50375   arg1 = (Dali::Rect< int > *)jarg1;
50376   result = (int) ((arg1)->right);
50377   jresult = result;
50378   return jresult;
50379 }
50380
50381
50382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50383   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50384   int arg2 ;
50385
50386   arg1 = (Dali::Rect< int > *)jarg1;
50387   arg2 = (int)jarg2;
50388   if (arg1) (arg1)->width = arg2;
50389 }
50390
50391
50392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50393   int jresult ;
50394   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50395   int result;
50396
50397   arg1 = (Dali::Rect< int > *)jarg1;
50398   result = (int) ((arg1)->width);
50399   jresult = result;
50400   return jresult;
50401 }
50402
50403
50404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50405   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50406   int arg2 ;
50407
50408   arg1 = (Dali::Rect< int > *)jarg1;
50409   arg2 = (int)jarg2;
50410   if (arg1) (arg1)->bottom = arg2;
50411 }
50412
50413
50414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50415   int jresult ;
50416   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50417   int result;
50418
50419   arg1 = (Dali::Rect< int > *)jarg1;
50420   result = (int) ((arg1)->bottom);
50421   jresult = result;
50422   return jresult;
50423 }
50424
50425
50426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50427   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50428   int arg2 ;
50429
50430   arg1 = (Dali::Rect< int > *)jarg1;
50431   arg2 = (int)jarg2;
50432   if (arg1) (arg1)->height = arg2;
50433 }
50434
50435
50436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50437   int jresult ;
50438   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50439   int result;
50440
50441   arg1 = (Dali::Rect< int > *)jarg1;
50442   result = (int) ((arg1)->height);
50443   jresult = result;
50444   return jresult;
50445 }
50446
50447
50448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50449   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50450   int arg2 ;
50451
50452   arg1 = (Dali::Rect< int > *)jarg1;
50453   arg2 = (int)jarg2;
50454   if (arg1) (arg1)->top = arg2;
50455 }
50456
50457
50458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50459   int jresult ;
50460   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50461   int result;
50462
50463   arg1 = (Dali::Rect< int > *)jarg1;
50464   result = (int) ((arg1)->top);
50465   jresult = result;
50466   return jresult;
50467 }
50468
50469
50470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50471   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50472
50473   arg1 = (Dali::Rect< int > *)jarg1;
50474   {
50475     try {
50476       delete arg1;
50477     } catch (std::out_of_range& e) {
50478       {
50479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50480       };
50481     } catch (std::exception& e) {
50482       {
50483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50484       };
50485     } catch (Dali::DaliException e) {
50486       {
50487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50488       };
50489     } catch (...) {
50490       {
50491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50492       };
50493     }
50494   }
50495
50496 }
50497
50498
50499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50500   void * jresult ;
50501   Dali::Rect< float > *result = 0 ;
50502
50503   {
50504     try {
50505       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50506     } catch (std::out_of_range& e) {
50507       {
50508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50509       };
50510     } catch (std::exception& e) {
50511       {
50512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50513       };
50514     } catch (Dali::DaliException e) {
50515       {
50516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50517       };
50518     } catch (...) {
50519       {
50520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50521       };
50522     }
50523   }
50524
50525   jresult = (void *)result;
50526   return jresult;
50527 }
50528
50529
50530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50531   void * jresult ;
50532   float arg1 ;
50533   float arg2 ;
50534   float arg3 ;
50535   float arg4 ;
50536   Dali::Rect< float > *result = 0 ;
50537
50538   arg1 = (float)jarg1;
50539   arg2 = (float)jarg2;
50540   arg3 = (float)jarg4;
50541   arg4 = (float)jarg3;
50542   {
50543     try {
50544       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50545     } catch (std::out_of_range& e) {
50546       {
50547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50548       };
50549     } catch (std::exception& e) {
50550       {
50551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50552       };
50553     } catch (Dali::DaliException e) {
50554       {
50555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50556       };
50557     } catch (...) {
50558       {
50559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50560       };
50561     }
50562   }
50563
50564   jresult = (void *)result;
50565   return jresult;
50566 }
50567
50568
50569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50570   void * jresult ;
50571   Dali::Rect< float > *arg1 = 0 ;
50572   Dali::Rect< float > *result = 0 ;
50573
50574   arg1 = (Dali::Rect< float > *)jarg1;
50575   if (!arg1) {
50576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50577     return 0;
50578   }
50579   {
50580     try {
50581       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50582     } catch (std::out_of_range& e) {
50583       {
50584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50585       };
50586     } catch (std::exception& e) {
50587       {
50588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50589       };
50590     } catch (Dali::DaliException e) {
50591       {
50592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50593       };
50594     } catch (...) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50597       };
50598     }
50599   }
50600
50601   jresult = (void *)result;
50602   return jresult;
50603 }
50604
50605
50606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50607   void * jresult ;
50608   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50609   Dali::Rect< float > *arg2 = 0 ;
50610   Dali::Rect< float > *result = 0 ;
50611
50612   arg1 = (Dali::Rect< float > *)jarg1;
50613   arg2 = (Dali::Rect< float > *)jarg2;
50614   if (!arg2) {
50615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50616     return 0;
50617   }
50618   {
50619     try {
50620       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50621     } catch (std::out_of_range& e) {
50622       {
50623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50624       };
50625     } catch (std::exception& e) {
50626       {
50627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50628       };
50629     } catch (Dali::DaliException e) {
50630       {
50631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50632       };
50633     } catch (...) {
50634       {
50635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50636       };
50637     }
50638   }
50639
50640   jresult = (void *)result;
50641   return jresult;
50642 }
50643
50644
50645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50646   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50647   float arg2 ;
50648   float arg3 ;
50649   float arg4 ;
50650   float arg5 ;
50651
50652   arg1 = (Dali::Rect< float > *)jarg1;
50653   arg2 = (float)jarg2;
50654   arg3 = (float)jarg3;
50655   arg4 = (float)jarg5;
50656   arg5 = (float)jarg4;
50657   {
50658     try {
50659       (arg1)->Set(arg2,arg3,arg4,arg5);
50660     } catch (std::out_of_range& e) {
50661       {
50662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50663       };
50664     } catch (std::exception& e) {
50665       {
50666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50667       };
50668     } catch (Dali::DaliException e) {
50669       {
50670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50671       };
50672     } catch (...) {
50673       {
50674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50675       };
50676     }
50677   }
50678
50679 }
50680
50681
50682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50683   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50684   float arg2 ;
50685
50686   arg1 = (Dali::Rect< float > *)jarg1;
50687   arg2 = (float)jarg2;
50688   if (arg1) (arg1)->left = arg2;
50689 }
50690
50691
50692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50693   float jresult ;
50694   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50695   float result;
50696
50697   arg1 = (Dali::Rect< float > *)jarg1;
50698   result = (float) ((arg1)->left);
50699   jresult = result;
50700   return jresult;
50701 }
50702
50703
50704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50705   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50706   float arg2 ;
50707
50708   arg1 = (Dali::Rect< float > *)jarg1;
50709   arg2 = (float)jarg2;
50710   if (arg1) (arg1)->left = arg2;
50711 }
50712
50713
50714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50715   float jresult ;
50716   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50717   float result;
50718
50719   arg1 = (Dali::Rect< float > *)jarg1;
50720   result = (float) ((arg1)->left);
50721   jresult = result;
50722   return jresult;
50723 }
50724
50725
50726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50727   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50728   float arg2 ;
50729
50730   arg1 = (Dali::Rect< float > *)jarg1;
50731   arg2 = (float)jarg2;
50732   if (arg1) (arg1)->right = arg2;
50733 }
50734
50735
50736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50737   float jresult ;
50738   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50739   float result;
50740
50741   arg1 = (Dali::Rect< float > *)jarg1;
50742   result = (float) ((arg1)->right);
50743   jresult = result;
50744   return jresult;
50745 }
50746
50747
50748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50749   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50750   float arg2 ;
50751
50752   arg1 = (Dali::Rect< float > *)jarg1;
50753   arg2 = (float)jarg2;
50754   if (arg1) (arg1)->right = arg2;
50755 }
50756
50757
50758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50759   float jresult ;
50760   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50761   float result;
50762
50763   arg1 = (Dali::Rect< float > *)jarg1;
50764   result = (float) ((arg1)->right);
50765   jresult = result;
50766   return jresult;
50767 }
50768
50769
50770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50771   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50772   float arg2 ;
50773
50774   arg1 = (Dali::Rect< float > *)jarg1;
50775   arg2 = (float)jarg2;
50776   if (arg1) (arg1)->bottom = arg2;
50777 }
50778
50779
50780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50781   float jresult ;
50782   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50783   float result;
50784
50785   arg1 = (Dali::Rect< float > *)jarg1;
50786   result = (float) ((arg1)->bottom);
50787   jresult = result;
50788   return jresult;
50789 }
50790
50791
50792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50793   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50794   float arg2 ;
50795
50796   arg1 = (Dali::Rect< float > *)jarg1;
50797   arg2 = (float)jarg2;
50798   if (arg1) (arg1)->top = arg2;
50799 }
50800
50801
50802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50803   float jresult ;
50804   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50805   float result;
50806
50807   arg1 = (Dali::Rect< float > *)jarg1;
50808   result = (float) ((arg1)->top);
50809   jresult = result;
50810   return jresult;
50811 }
50812
50813
50814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50815   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50816
50817   arg1 = (Dali::Rect< float > *)jarg1;
50818   {
50819     try {
50820       delete arg1;
50821     } catch (std::out_of_range& e) {
50822       {
50823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50824       };
50825     } catch (std::exception& e) {
50826       {
50827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50828       };
50829     } catch (Dali::DaliException e) {
50830       {
50831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50832       };
50833     } catch (...) {
50834       {
50835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50836       };
50837     }
50838   }
50839
50840 }
50841
50842
50843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
50844   int jresult ;
50845   int result;
50846
50847   result = (int)Dali::Vector< int >::BaseType;
50848   jresult = (int)result;
50849   return jresult;
50850 }
50851
50852
50853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
50854   void * jresult ;
50855   Dali::Vector< int > *result = 0 ;
50856
50857   {
50858     try {
50859       result = (Dali::Vector< int > *)new Dali::Vector< int >();
50860     } catch (std::out_of_range& e) {
50861       {
50862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50863       };
50864     } catch (std::exception& e) {
50865       {
50866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50867       };
50868     } catch (Dali::DaliException e) {
50869       {
50870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50871       };
50872     } catch (...) {
50873       {
50874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50875       };
50876     }
50877   }
50878
50879   jresult = (void *)result;
50880   return jresult;
50881 }
50882
50883
50884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
50885   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50886
50887   arg1 = (Dali::Vector< int > *)jarg1;
50888   {
50889     try {
50890       delete arg1;
50891     } catch (std::out_of_range& e) {
50892       {
50893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50894       };
50895     } catch (std::exception& e) {
50896       {
50897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50898       };
50899     } catch (Dali::DaliException e) {
50900       {
50901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50902       };
50903     } catch (...) {
50904       {
50905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50906       };
50907     }
50908   }
50909
50910 }
50911
50912
50913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
50914   void * jresult ;
50915   Dali::Vector< int > *arg1 = 0 ;
50916   Dali::Vector< int > *result = 0 ;
50917
50918   arg1 = (Dali::Vector< int > *)jarg1;
50919   if (!arg1) {
50920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50921     return 0;
50922   }
50923   {
50924     try {
50925       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
50926     } catch (std::out_of_range& e) {
50927       {
50928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50929       };
50930     } catch (std::exception& e) {
50931       {
50932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50933       };
50934     } catch (Dali::DaliException e) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50937       };
50938     } catch (...) {
50939       {
50940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50941       };
50942     }
50943   }
50944
50945   jresult = (void *)result;
50946   return jresult;
50947 }
50948
50949
50950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
50951   void * jresult ;
50952   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50953   Dali::Vector< int > *arg2 = 0 ;
50954   Dali::Vector< int > *result = 0 ;
50955
50956   arg1 = (Dali::Vector< int > *)jarg1;
50957   arg2 = (Dali::Vector< int > *)jarg2;
50958   if (!arg2) {
50959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50960     return 0;
50961   }
50962   {
50963     try {
50964       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
50965     } catch (std::out_of_range& e) {
50966       {
50967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50968       };
50969     } catch (std::exception& e) {
50970       {
50971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50972       };
50973     } catch (Dali::DaliException e) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50976       };
50977     } catch (...) {
50978       {
50979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50980       };
50981     }
50982   }
50983
50984   jresult = (void *)result;
50985   return jresult;
50986 }
50987
50988
50989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
50990   void * jresult ;
50991   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50992   Dali::Vector< int >::Iterator result;
50993
50994   arg1 = (Dali::Vector< int > *)jarg1;
50995   {
50996     try {
50997       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
50998     } catch (std::out_of_range& e) {
50999       {
51000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51001       };
51002     } catch (std::exception& e) {
51003       {
51004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51005       };
51006     } catch (Dali::DaliException e) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51009       };
51010     } catch (...) {
51011       {
51012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51013       };
51014     }
51015   }
51016
51017   jresult = (void *)result;
51018   return jresult;
51019 }
51020
51021
51022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51023   void * jresult ;
51024   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51025   Dali::Vector< int >::Iterator result;
51026
51027   arg1 = (Dali::Vector< int > *)jarg1;
51028   {
51029     try {
51030       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51031     } catch (std::out_of_range& e) {
51032       {
51033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51034       };
51035     } catch (std::exception& e) {
51036       {
51037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (Dali::DaliException e) {
51040       {
51041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51042       };
51043     } catch (...) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51046       };
51047     }
51048   }
51049
51050   jresult = (void *)result;
51051   return jresult;
51052 }
51053
51054
51055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51056   void * jresult ;
51057   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51058   Dali::Vector< int >::SizeType arg2 ;
51059   Dali::Vector< int >::ItemType *result = 0 ;
51060
51061   arg1 = (Dali::Vector< int > *)jarg1;
51062   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51063   {
51064     try {
51065       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51066     } catch (std::out_of_range& e) {
51067       {
51068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51069       };
51070     } catch (std::exception& e) {
51071       {
51072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51073       };
51074     } catch (Dali::DaliException e) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51077       };
51078     } catch (...) {
51079       {
51080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51081       };
51082     }
51083   }
51084
51085   jresult = (void *)result;
51086   return jresult;
51087 }
51088
51089
51090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51091   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51092   Dali::Vector< int >::ItemType *arg2 = 0 ;
51093   Dali::Vector< int >::ItemType temp2 ;
51094
51095   arg1 = (Dali::Vector< int > *)jarg1;
51096   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51097   arg2 = &temp2;
51098   {
51099     try {
51100       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51101     } catch (std::out_of_range& e) {
51102       {
51103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51104       };
51105     } catch (std::exception& e) {
51106       {
51107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51108       };
51109     } catch (Dali::DaliException e) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51112       };
51113     } catch (...) {
51114       {
51115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51116       };
51117     }
51118   }
51119
51120 }
51121
51122
51123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51124   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51125   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51126   Dali::Vector< int >::ItemType *arg3 = 0 ;
51127   Dali::Vector< int >::ItemType temp3 ;
51128
51129   arg1 = (Dali::Vector< int > *)jarg1;
51130   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51131   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51132   arg3 = &temp3;
51133   {
51134     try {
51135       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51136     } catch (std::out_of_range& e) {
51137       {
51138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51139       };
51140     } catch (std::exception& e) {
51141       {
51142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51143       };
51144     } catch (Dali::DaliException e) {
51145       {
51146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51147       };
51148     } catch (...) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51151       };
51152     }
51153   }
51154
51155 }
51156
51157
51158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51159   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51160   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51161   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51162   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51163
51164   arg1 = (Dali::Vector< int > *)jarg1;
51165   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51166   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51167   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51168   {
51169     try {
51170       (arg1)->Insert(arg2,arg3,arg4);
51171     } catch (std::out_of_range& e) {
51172       {
51173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51174       };
51175     } catch (std::exception& e) {
51176       {
51177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51178       };
51179     } catch (Dali::DaliException e) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51182       };
51183     } catch (...) {
51184       {
51185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51186       };
51187     }
51188   }
51189
51190 }
51191
51192
51193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51194   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51195   Dali::Vector< int >::SizeType arg2 ;
51196
51197   arg1 = (Dali::Vector< int > *)jarg1;
51198   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51199   {
51200     try {
51201       (arg1)->Reserve(arg2);
51202     } catch (std::out_of_range& e) {
51203       {
51204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51205       };
51206     } catch (std::exception& e) {
51207       {
51208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51209       };
51210     } catch (Dali::DaliException e) {
51211       {
51212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51213       };
51214     } catch (...) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51217       };
51218     }
51219   }
51220
51221 }
51222
51223
51224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51225   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51226   Dali::Vector< int >::SizeType arg2 ;
51227
51228   arg1 = (Dali::Vector< int > *)jarg1;
51229   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51230   {
51231     try {
51232       (arg1)->Resize(arg2);
51233     } catch (std::out_of_range& e) {
51234       {
51235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51236       };
51237     } catch (std::exception& e) {
51238       {
51239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51240       };
51241     } catch (Dali::DaliException e) {
51242       {
51243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51244       };
51245     } catch (...) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51248       };
51249     }
51250   }
51251
51252 }
51253
51254
51255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51256   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51257   Dali::Vector< int >::SizeType arg2 ;
51258   Dali::Vector< int >::ItemType *arg3 = 0 ;
51259   Dali::Vector< int >::ItemType temp3 ;
51260
51261   arg1 = (Dali::Vector< int > *)jarg1;
51262   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51263   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51264   arg3 = &temp3;
51265   {
51266     try {
51267       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51268     } catch (std::out_of_range& e) {
51269       {
51270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51271       };
51272     } catch (std::exception& e) {
51273       {
51274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51275       };
51276     } catch (Dali::DaliException e) {
51277       {
51278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51279       };
51280     } catch (...) {
51281       {
51282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51283       };
51284     }
51285   }
51286
51287 }
51288
51289
51290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51291   void * jresult ;
51292   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51293   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51294   Dali::Vector< int >::Iterator result;
51295
51296   arg1 = (Dali::Vector< int > *)jarg1;
51297   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51298   {
51299     try {
51300       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51301     } catch (std::out_of_range& e) {
51302       {
51303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51304       };
51305     } catch (std::exception& e) {
51306       {
51307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51308       };
51309     } catch (Dali::DaliException e) {
51310       {
51311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51312       };
51313     } catch (...) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51316       };
51317     }
51318   }
51319
51320   jresult = (void *)result;
51321   return jresult;
51322 }
51323
51324
51325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51326   void * jresult ;
51327   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51328   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51329   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51330   Dali::Vector< int >::Iterator result;
51331
51332   arg1 = (Dali::Vector< int > *)jarg1;
51333   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51334   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51335   {
51336     try {
51337       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51338     } catch (std::out_of_range& e) {
51339       {
51340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (std::exception& e) {
51343       {
51344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51345       };
51346     } catch (Dali::DaliException e) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51349       };
51350     } catch (...) {
51351       {
51352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51353       };
51354     }
51355   }
51356
51357   jresult = (void *)result;
51358   return jresult;
51359 }
51360
51361
51362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51363   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51364   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51365
51366   arg1 = (Dali::Vector< int > *)jarg1;
51367   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51368   {
51369     try {
51370       (arg1)->Remove(arg2);
51371     } catch (std::out_of_range& e) {
51372       {
51373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51374       };
51375     } catch (std::exception& e) {
51376       {
51377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51378       };
51379     } catch (Dali::DaliException e) {
51380       {
51381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51382       };
51383     } catch (...) {
51384       {
51385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51386       };
51387     }
51388   }
51389
51390 }
51391
51392
51393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51394   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51395   Dali::Vector< int > *arg2 = 0 ;
51396
51397   arg1 = (Dali::Vector< int > *)jarg1;
51398   arg2 = (Dali::Vector< int > *)jarg2;
51399   if (!arg2) {
51400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51401     return ;
51402   }
51403   {
51404     try {
51405       (arg1)->Swap(*arg2);
51406     } catch (std::out_of_range& e) {
51407       {
51408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51409       };
51410     } catch (std::exception& e) {
51411       {
51412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51413       };
51414     } catch (Dali::DaliException e) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51417       };
51418     } catch (...) {
51419       {
51420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51421       };
51422     }
51423   }
51424
51425 }
51426
51427
51428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51429   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   {
51433     try {
51434       (arg1)->Clear();
51435     } catch (std::out_of_range& e) {
51436       {
51437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51438       };
51439     } catch (std::exception& e) {
51440       {
51441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (Dali::DaliException e) {
51444       {
51445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51446       };
51447     } catch (...) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51450       };
51451     }
51452   }
51453
51454 }
51455
51456
51457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51458   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51459
51460   arg1 = (Dali::Vector< int > *)jarg1;
51461   {
51462     try {
51463       (arg1)->Release();
51464     } catch (std::out_of_range& e) {
51465       {
51466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51467       };
51468     } catch (std::exception& e) {
51469       {
51470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51471       };
51472     } catch (Dali::DaliException e) {
51473       {
51474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51475       };
51476     } catch (...) {
51477       {
51478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51479       };
51480     }
51481   }
51482
51483 }
51484
51485
51486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51487   int jresult ;
51488   int result;
51489
51490   result = (int)Dali::Vector< float >::BaseType;
51491   jresult = (int)result;
51492   return jresult;
51493 }
51494
51495
51496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51497   void * jresult ;
51498   Dali::Vector< float > *result = 0 ;
51499
51500   {
51501     try {
51502       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51503     } catch (std::out_of_range& e) {
51504       {
51505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51506       };
51507     } catch (std::exception& e) {
51508       {
51509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51510       };
51511     } catch (Dali::DaliException e) {
51512       {
51513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51514       };
51515     } catch (...) {
51516       {
51517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51518       };
51519     }
51520   }
51521
51522   jresult = (void *)result;
51523   return jresult;
51524 }
51525
51526
51527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51528   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51529
51530   arg1 = (Dali::Vector< float > *)jarg1;
51531   {
51532     try {
51533       delete arg1;
51534     } catch (std::out_of_range& e) {
51535       {
51536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51537       };
51538     } catch (std::exception& e) {
51539       {
51540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51541       };
51542     } catch (Dali::DaliException e) {
51543       {
51544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51545       };
51546     } catch (...) {
51547       {
51548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51549       };
51550     }
51551   }
51552
51553 }
51554
51555
51556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51557   void * jresult ;
51558   Dali::Vector< float > *arg1 = 0 ;
51559   Dali::Vector< float > *result = 0 ;
51560
51561   arg1 = (Dali::Vector< float > *)jarg1;
51562   if (!arg1) {
51563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51564     return 0;
51565   }
51566   {
51567     try {
51568       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51569     } catch (std::out_of_range& e) {
51570       {
51571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51572       };
51573     } catch (std::exception& e) {
51574       {
51575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51576       };
51577     } catch (Dali::DaliException e) {
51578       {
51579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51580       };
51581     } catch (...) {
51582       {
51583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51584       };
51585     }
51586   }
51587
51588   jresult = (void *)result;
51589   return jresult;
51590 }
51591
51592
51593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51594   void * jresult ;
51595   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51596   Dali::Vector< float > *arg2 = 0 ;
51597   Dali::Vector< float > *result = 0 ;
51598
51599   arg1 = (Dali::Vector< float > *)jarg1;
51600   arg2 = (Dali::Vector< float > *)jarg2;
51601   if (!arg2) {
51602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51603     return 0;
51604   }
51605   {
51606     try {
51607       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51608     } catch (std::out_of_range& e) {
51609       {
51610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51611       };
51612     } catch (std::exception& e) {
51613       {
51614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51615       };
51616     } catch (Dali::DaliException e) {
51617       {
51618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51619       };
51620     } catch (...) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51623       };
51624     }
51625   }
51626
51627   jresult = (void *)result;
51628   return jresult;
51629 }
51630
51631
51632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51633   void * jresult ;
51634   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51635   Dali::Vector< float >::Iterator result;
51636
51637   arg1 = (Dali::Vector< float > *)jarg1;
51638   {
51639     try {
51640       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51641     } catch (std::out_of_range& e) {
51642       {
51643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51644       };
51645     } catch (std::exception& e) {
51646       {
51647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (Dali::DaliException e) {
51650       {
51651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659
51660   jresult = (void *)result;
51661   return jresult;
51662 }
51663
51664
51665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51666   void * jresult ;
51667   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51668   Dali::Vector< float >::Iterator result;
51669
51670   arg1 = (Dali::Vector< float > *)jarg1;
51671   {
51672     try {
51673       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51674     } catch (std::out_of_range& e) {
51675       {
51676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51677       };
51678     } catch (std::exception& e) {
51679       {
51680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (Dali::DaliException e) {
51683       {
51684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692
51693   jresult = (void *)result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51699   void * jresult ;
51700   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51701   Dali::Vector< float >::SizeType arg2 ;
51702   Dali::Vector< float >::ItemType *result = 0 ;
51703
51704   arg1 = (Dali::Vector< float > *)jarg1;
51705   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51706   {
51707     try {
51708       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51709     } catch (std::out_of_range& e) {
51710       {
51711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51712       };
51713     } catch (std::exception& e) {
51714       {
51715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51716       };
51717     } catch (Dali::DaliException e) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51720       };
51721     } catch (...) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51724       };
51725     }
51726   }
51727
51728   jresult = (void *)result;
51729   return jresult;
51730 }
51731
51732
51733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51734   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51735   Dali::Vector< float >::ItemType *arg2 = 0 ;
51736   Dali::Vector< float >::ItemType temp2 ;
51737
51738   arg1 = (Dali::Vector< float > *)jarg1;
51739   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51740   arg2 = &temp2;
51741   {
51742     try {
51743       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51744     } catch (std::out_of_range& e) {
51745       {
51746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (std::exception& e) {
51749       {
51750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51751       };
51752     } catch (Dali::DaliException e) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51755       };
51756     } catch (...) {
51757       {
51758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51759       };
51760     }
51761   }
51762
51763 }
51764
51765
51766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51767   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51768   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51769   Dali::Vector< float >::ItemType *arg3 = 0 ;
51770   Dali::Vector< float >::ItemType temp3 ;
51771
51772   arg1 = (Dali::Vector< float > *)jarg1;
51773   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51774   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51775   arg3 = &temp3;
51776   {
51777     try {
51778       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51779     } catch (std::out_of_range& e) {
51780       {
51781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51782       };
51783     } catch (std::exception& e) {
51784       {
51785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51786       };
51787     } catch (Dali::DaliException e) {
51788       {
51789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51790       };
51791     } catch (...) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51794       };
51795     }
51796   }
51797
51798 }
51799
51800
51801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51802   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51803   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51804   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51805   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51806
51807   arg1 = (Dali::Vector< float > *)jarg1;
51808   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51809   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51810   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51811   {
51812     try {
51813       (arg1)->Insert(arg2,arg3,arg4);
51814     } catch (std::out_of_range& e) {
51815       {
51816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51817       };
51818     } catch (std::exception& e) {
51819       {
51820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51821       };
51822     } catch (Dali::DaliException e) {
51823       {
51824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51825       };
51826     } catch (...) {
51827       {
51828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51829       };
51830     }
51831   }
51832
51833 }
51834
51835
51836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
51837   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51838   Dali::Vector< float >::SizeType arg2 ;
51839
51840   arg1 = (Dali::Vector< float > *)jarg1;
51841   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51842   {
51843     try {
51844       (arg1)->Reserve(arg2);
51845     } catch (std::out_of_range& e) {
51846       {
51847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51848       };
51849     } catch (std::exception& e) {
51850       {
51851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51852       };
51853     } catch (Dali::DaliException e) {
51854       {
51855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51856       };
51857     } catch (...) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51860       };
51861     }
51862   }
51863
51864 }
51865
51866 //// ========================= end of part 2 =============================
51867
51868 //// ========================== start part 3 ===============================
51869
51870
51871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51872   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51873   Dali::Vector< float >::SizeType arg2 ;
51874
51875   arg1 = (Dali::Vector< float > *)jarg1;
51876   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51877   {
51878     try {
51879       (arg1)->Resize(arg2);
51880     } catch (std::out_of_range& e) {
51881       {
51882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51883       };
51884     } catch (std::exception& e) {
51885       {
51886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51887       };
51888     } catch (Dali::DaliException e) {
51889       {
51890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51891       };
51892     } catch (...) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51895       };
51896     }
51897   }
51898
51899 }
51900
51901
51902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
51903   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51904   Dali::Vector< float >::SizeType arg2 ;
51905   Dali::Vector< float >::ItemType *arg3 = 0 ;
51906   Dali::Vector< float >::ItemType temp3 ;
51907
51908   arg1 = (Dali::Vector< float > *)jarg1;
51909   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51910   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51911   arg3 = &temp3;
51912   {
51913     try {
51914       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51915     } catch (std::out_of_range& e) {
51916       {
51917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (std::exception& e) {
51920       {
51921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (Dali::DaliException e) {
51924       {
51925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51926       };
51927     } catch (...) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51930       };
51931     }
51932   }
51933
51934 }
51935
51936
51937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
51938   void * jresult ;
51939   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51940   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51941   Dali::Vector< float >::Iterator result;
51942
51943   arg1 = (Dali::Vector< float > *)jarg1;
51944   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51945   {
51946     try {
51947       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
51948     } catch (std::out_of_range& e) {
51949       {
51950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51951       };
51952     } catch (std::exception& e) {
51953       {
51954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51955       };
51956     } catch (Dali::DaliException e) {
51957       {
51958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51959       };
51960     } catch (...) {
51961       {
51962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51963       };
51964     }
51965   }
51966
51967   jresult = (void *)result;
51968   return jresult;
51969 }
51970
51971
51972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51973   void * jresult ;
51974   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51975   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51976   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51977   Dali::Vector< float >::Iterator result;
51978
51979   arg1 = (Dali::Vector< float > *)jarg1;
51980   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51981   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51982   {
51983     try {
51984       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
51985     } catch (std::out_of_range& e) {
51986       {
51987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51988       };
51989     } catch (std::exception& e) {
51990       {
51991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51992       };
51993     } catch (Dali::DaliException e) {
51994       {
51995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51996       };
51997     } catch (...) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52000       };
52001     }
52002   }
52003
52004   jresult = (void *)result;
52005   return jresult;
52006 }
52007
52008
52009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52010   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52011   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52012
52013   arg1 = (Dali::Vector< float > *)jarg1;
52014   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52015   {
52016     try {
52017       (arg1)->Remove(arg2);
52018     } catch (std::out_of_range& e) {
52019       {
52020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52021       };
52022     } catch (std::exception& e) {
52023       {
52024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52025       };
52026     } catch (Dali::DaliException e) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52029       };
52030     } catch (...) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52033       };
52034     }
52035   }
52036
52037 }
52038
52039
52040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52041   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52042   Dali::Vector< float > *arg2 = 0 ;
52043
52044   arg1 = (Dali::Vector< float > *)jarg1;
52045   arg2 = (Dali::Vector< float > *)jarg2;
52046   if (!arg2) {
52047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52048     return ;
52049   }
52050   {
52051     try {
52052       (arg1)->Swap(*arg2);
52053     } catch (std::out_of_range& e) {
52054       {
52055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52056       };
52057     } catch (std::exception& e) {
52058       {
52059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (Dali::DaliException e) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52064       };
52065     } catch (...) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52068       };
52069     }
52070   }
52071
52072 }
52073
52074
52075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52076   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52077
52078   arg1 = (Dali::Vector< float > *)jarg1;
52079   {
52080     try {
52081       (arg1)->Clear();
52082     } catch (std::out_of_range& e) {
52083       {
52084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (std::exception& e) {
52087       {
52088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52089       };
52090     } catch (Dali::DaliException e) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52093       };
52094     } catch (...) {
52095       {
52096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52097       };
52098     }
52099   }
52100
52101 }
52102
52103
52104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52105   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52106
52107   arg1 = (Dali::Vector< float > *)jarg1;
52108   {
52109     try {
52110       (arg1)->Release();
52111     } catch (std::out_of_range& e) {
52112       {
52113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52114       };
52115     } catch (std::exception& e) {
52116       {
52117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52118       };
52119     } catch (Dali::DaliException e) {
52120       {
52121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52122       };
52123     } catch (...) {
52124       {
52125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52126       };
52127     }
52128   }
52129
52130 }
52131
52132
52133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52134   int jresult ;
52135   int result;
52136
52137   result = (int)Dali::Vector< unsigned char >::BaseType;
52138   jresult = (int)result;
52139   return jresult;
52140 }
52141
52142
52143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52144   void * jresult ;
52145   Dali::Vector< unsigned char > *result = 0 ;
52146
52147   {
52148     try {
52149       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52150     } catch (std::out_of_range& e) {
52151       {
52152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52153       };
52154     } catch (std::exception& e) {
52155       {
52156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52157       };
52158     } catch (Dali::DaliException e) {
52159       {
52160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52161       };
52162     } catch (...) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52165       };
52166     }
52167   }
52168
52169   jresult = (void *)result;
52170   return jresult;
52171 }
52172
52173
52174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52175   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52176
52177   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52178   {
52179     try {
52180       delete arg1;
52181     } catch (std::out_of_range& e) {
52182       {
52183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52184       };
52185     } catch (std::exception& e) {
52186       {
52187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52188       };
52189     } catch (Dali::DaliException e) {
52190       {
52191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52192       };
52193     } catch (...) {
52194       {
52195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52196       };
52197     }
52198   }
52199
52200 }
52201
52202
52203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52204   void * jresult ;
52205   Dali::Vector< unsigned char > *arg1 = 0 ;
52206   Dali::Vector< unsigned char > *result = 0 ;
52207
52208   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52209   if (!arg1) {
52210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52211     return 0;
52212   }
52213   {
52214     try {
52215       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52216     } catch (std::out_of_range& e) {
52217       {
52218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52219       };
52220     } catch (std::exception& e) {
52221       {
52222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52223       };
52224     } catch (Dali::DaliException e) {
52225       {
52226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52231       };
52232     }
52233   }
52234
52235   jresult = (void *)result;
52236   return jresult;
52237 }
52238
52239
52240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52241   void * jresult ;
52242   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52243   Dali::Vector< unsigned char > *arg2 = 0 ;
52244   Dali::Vector< unsigned char > *result = 0 ;
52245
52246   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52247   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52248   if (!arg2) {
52249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52250     return 0;
52251   }
52252   {
52253     try {
52254       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52255     } catch (std::out_of_range& e) {
52256       {
52257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52258       };
52259     } catch (std::exception& e) {
52260       {
52261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52262       };
52263     } catch (Dali::DaliException e) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52266       };
52267     } catch (...) {
52268       {
52269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52270       };
52271     }
52272   }
52273
52274   jresult = (void *)result;
52275   return jresult;
52276 }
52277
52278
52279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52280   void * jresult ;
52281   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52282   Dali::Vector< unsigned char >::Iterator result;
52283
52284   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52285   {
52286     try {
52287       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52288     } catch (std::out_of_range& e) {
52289       {
52290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52291       };
52292     } catch (std::exception& e) {
52293       {
52294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52295       };
52296     } catch (Dali::DaliException e) {
52297       {
52298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52303       };
52304     }
52305   }
52306
52307   jresult = (void *)result;
52308   return jresult;
52309 }
52310
52311
52312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52313   void * jresult ;
52314   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52315   Dali::Vector< unsigned char >::Iterator result;
52316
52317   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52318   {
52319     try {
52320       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52321     } catch (std::out_of_range& e) {
52322       {
52323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52324       };
52325     } catch (std::exception& e) {
52326       {
52327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (Dali::DaliException e) {
52330       {
52331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52332       };
52333     } catch (...) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52336       };
52337     }
52338   }
52339
52340   jresult = (void *)result;
52341   return jresult;
52342 }
52343
52344
52345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52346   void * jresult ;
52347   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52348   Dali::Vector< unsigned char >::SizeType arg2 ;
52349   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52350
52351   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52352   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52353   {
52354     try {
52355       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52356     } catch (std::out_of_range& e) {
52357       {
52358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52359       };
52360     } catch (std::exception& e) {
52361       {
52362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52363       };
52364     } catch (Dali::DaliException e) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52367       };
52368     } catch (...) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52371       };
52372     }
52373   }
52374
52375   jresult = (void *)result;
52376   return jresult;
52377 }
52378
52379
52380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52381   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52382   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52383   Dali::Vector< unsigned char >::ItemType temp2 ;
52384
52385   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52386   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52387   arg2 = &temp2;
52388   {
52389     try {
52390       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52398       };
52399     } catch (Dali::DaliException e) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52402       };
52403     } catch (...) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52406       };
52407     }
52408   }
52409
52410 }
52411
52412
52413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52414   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52415   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52416   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52417   Dali::Vector< unsigned char >::ItemType temp3 ;
52418
52419   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52420   arg2 = jarg2;
52421   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52422   arg3 = &temp3;
52423   {
52424     try {
52425       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52433       };
52434     } catch (Dali::DaliException e) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52437       };
52438     } catch (...) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52441       };
52442     }
52443   }
52444
52445
52446
52447 }
52448
52449
52450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52451   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52452   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52453   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52454   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52455
52456   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52457   arg2 = jarg2;
52458   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52459   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52460   {
52461     try {
52462       (arg1)->Insert(arg2,arg3,arg4);
52463     } catch (std::out_of_range& e) {
52464       {
52465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52466       };
52467     } catch (std::exception& e) {
52468       {
52469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52470       };
52471     } catch (Dali::DaliException e) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52474       };
52475     } catch (...) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52478       };
52479     }
52480   }
52481
52482
52483
52484 }
52485
52486
52487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52488   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52489   Dali::Vector< unsigned char >::SizeType arg2 ;
52490
52491   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52492   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52493   {
52494     try {
52495       (arg1)->Reserve(arg2);
52496     } catch (std::out_of_range& e) {
52497       {
52498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52499       };
52500     } catch (std::exception& e) {
52501       {
52502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52503       };
52504     } catch (Dali::DaliException e) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52507       };
52508     } catch (...) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52511       };
52512     }
52513   }
52514
52515 }
52516
52517
52518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52519   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52520   Dali::Vector< unsigned char >::SizeType arg2 ;
52521
52522   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52523   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52524   {
52525     try {
52526       (arg1)->Resize(arg2);
52527     } catch (std::out_of_range& e) {
52528       {
52529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52530       };
52531     } catch (std::exception& e) {
52532       {
52533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52534       };
52535     } catch (Dali::DaliException e) {
52536       {
52537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52538       };
52539     } catch (...) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52542       };
52543     }
52544   }
52545
52546 }
52547
52548
52549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52550   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52551   Dali::Vector< unsigned char >::SizeType arg2 ;
52552   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52553   Dali::Vector< unsigned char >::ItemType temp3 ;
52554
52555   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52556   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52557   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52558   arg3 = &temp3;
52559   {
52560     try {
52561       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52562     } catch (std::out_of_range& e) {
52563       {
52564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52565       };
52566     } catch (std::exception& e) {
52567       {
52568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (Dali::DaliException e) {
52571       {
52572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52573       };
52574     } catch (...) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52577       };
52578     }
52579   }
52580
52581 }
52582
52583
52584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52585   void * jresult ;
52586   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52587   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52588   Dali::Vector< unsigned char >::Iterator result;
52589
52590   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52591   arg2 = jarg2;
52592   {
52593     try {
52594       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52595     } catch (std::out_of_range& e) {
52596       {
52597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52598       };
52599     } catch (std::exception& e) {
52600       {
52601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52602       };
52603     } catch (Dali::DaliException e) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52610       };
52611     }
52612   }
52613
52614   jresult = (void *)result;
52615
52616
52617   return jresult;
52618 }
52619
52620
52621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52622   void * jresult ;
52623   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52624   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52625   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52626   Dali::Vector< unsigned char >::Iterator result;
52627
52628   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52629   arg2 = jarg2;
52630   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52631   {
52632     try {
52633       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52641       };
52642     } catch (Dali::DaliException e) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52645       };
52646     } catch (...) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52649       };
52650     }
52651   }
52652
52653   jresult = (void *)result;
52654
52655
52656   return jresult;
52657 }
52658
52659
52660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52661   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52662   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52663
52664   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52665   arg2 = jarg2;
52666   {
52667     try {
52668       (arg1)->Remove(arg2);
52669     } catch (std::out_of_range& e) {
52670       {
52671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52672       };
52673     } catch (std::exception& e) {
52674       {
52675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52676       };
52677     } catch (Dali::DaliException e) {
52678       {
52679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52680       };
52681     } catch (...) {
52682       {
52683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52684       };
52685     }
52686   }
52687
52688
52689
52690 }
52691
52692
52693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52694   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52695   Dali::Vector< unsigned char > *arg2 = 0 ;
52696
52697   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52698   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52699   if (!arg2) {
52700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52701     return ;
52702   }
52703   {
52704     try {
52705       (arg1)->Swap(*arg2);
52706     } catch (std::out_of_range& e) {
52707       {
52708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (std::exception& e) {
52711       {
52712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (Dali::DaliException e) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52717       };
52718     } catch (...) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52721       };
52722     }
52723   }
52724
52725 }
52726
52727
52728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52729   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52730
52731   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52732   {
52733     try {
52734       (arg1)->Clear();
52735     } catch (std::out_of_range& e) {
52736       {
52737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52738       };
52739     } catch (std::exception& e) {
52740       {
52741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52742       };
52743     } catch (Dali::DaliException e) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52746       };
52747     } catch (...) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52750       };
52751     }
52752   }
52753
52754 }
52755
52756
52757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52758   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52759
52760   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52761   {
52762     try {
52763       (arg1)->Release();
52764     } catch (std::out_of_range& e) {
52765       {
52766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52767       };
52768     } catch (std::exception& e) {
52769       {
52770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52771       };
52772     } catch (Dali::DaliException e) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52775       };
52776     } catch (...) {
52777       {
52778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52779       };
52780     }
52781   }
52782
52783 }
52784
52785
52786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52787   int jresult ;
52788   int result;
52789
52790   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52791   jresult = (int)result;
52792   return jresult;
52793 }
52794
52795
52796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52797   void * jresult ;
52798   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52799
52800   {
52801     try {
52802       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52803     } catch (std::out_of_range& e) {
52804       {
52805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52806       };
52807     } catch (std::exception& e) {
52808       {
52809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52810       };
52811     } catch (Dali::DaliException e) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52814       };
52815     } catch (...) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52818       };
52819     }
52820   }
52821
52822   jresult = (void *)result;
52823   return jresult;
52824 }
52825
52826
52827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52828   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52829
52830   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52831   {
52832     try {
52833       delete arg1;
52834     } catch (std::out_of_range& e) {
52835       {
52836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52837       };
52838     } catch (std::exception& e) {
52839       {
52840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52841       };
52842     } catch (Dali::DaliException e) {
52843       {
52844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52845       };
52846     } catch (...) {
52847       {
52848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52849       };
52850     }
52851   }
52852
52853 }
52854
52855
52856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
52857   void * jresult ;
52858   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
52859   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52860
52861   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52862   if (!arg1) {
52863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52864     return 0;
52865   }
52866   {
52867     try {
52868       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
52869     } catch (std::out_of_range& e) {
52870       {
52871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52872       };
52873     } catch (std::exception& e) {
52874       {
52875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52876       };
52877     } catch (Dali::DaliException e) {
52878       {
52879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52880       };
52881     } catch (...) {
52882       {
52883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52884       };
52885     }
52886   }
52887
52888   jresult = (void *)result;
52889   return jresult;
52890 }
52891
52892
52893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
52894   void * jresult ;
52895   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52896   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52897   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52898
52899   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52900   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52901   if (!arg2) {
52902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52903     return 0;
52904   }
52905   {
52906     try {
52907       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
52908     } catch (std::out_of_range& e) {
52909       {
52910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52911       };
52912     } catch (std::exception& e) {
52913       {
52914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52915       };
52916     } catch (Dali::DaliException e) {
52917       {
52918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52919       };
52920     } catch (...) {
52921       {
52922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52923       };
52924     }
52925   }
52926
52927   jresult = (void *)result;
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
52933   void * jresult ;
52934   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52935   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52936
52937   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52938   {
52939     try {
52940       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
52941     } catch (std::out_of_range& e) {
52942       {
52943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52944       };
52945     } catch (std::exception& e) {
52946       {
52947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52948       };
52949     } catch (Dali::DaliException e) {
52950       {
52951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52952       };
52953     } catch (...) {
52954       {
52955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52956       };
52957     }
52958   }
52959
52960   jresult = (void *)result;
52961   return jresult;
52962 }
52963
52964
52965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
52966   void * jresult ;
52967   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52968   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52969
52970   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52971   {
52972     try {
52973       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
52974     } catch (std::out_of_range& e) {
52975       {
52976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (std::exception& e) {
52979       {
52980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (Dali::DaliException e) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52985       };
52986     } catch (...) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52989       };
52990     }
52991   }
52992
52993   jresult = (void *)result;
52994   return jresult;
52995 }
52996
52997
52998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52999   void * jresult ;
53000   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53001   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53002   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53003
53004   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53005   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53006   {
53007     try {
53008       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53009     } catch (std::out_of_range& e) {
53010       {
53011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53012       };
53013     } catch (std::exception& e) {
53014       {
53015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53016       };
53017     } catch (Dali::DaliException e) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53020       };
53021     } catch (...) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53024       };
53025     }
53026   }
53027
53028   jresult = (void *)result;
53029   return jresult;
53030 }
53031
53032
53033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53034   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53035   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53036
53037   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53038   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53039   if (!arg2) {
53040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53041     return ;
53042   }
53043   {
53044     try {
53045       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53046     } catch (std::out_of_range& e) {
53047       {
53048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53049       };
53050     } catch (std::exception& e) {
53051       {
53052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53053       };
53054     } catch (Dali::DaliException e) {
53055       {
53056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53057       };
53058     } catch (...) {
53059       {
53060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53061       };
53062     }
53063   }
53064
53065 }
53066
53067
53068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53069   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53070   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53071   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53072
53073   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53074   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53075   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53076   if (!arg3) {
53077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53078     return ;
53079   }
53080   {
53081     try {
53082       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53083     } catch (std::out_of_range& e) {
53084       {
53085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53086       };
53087     } catch (std::exception& e) {
53088       {
53089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53090       };
53091     } catch (Dali::DaliException e) {
53092       {
53093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53094       };
53095     } catch (...) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53098       };
53099     }
53100   }
53101
53102 }
53103
53104
53105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53106   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53107   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53108   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53109   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53110
53111   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53112   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53113   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53114   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53115   {
53116     try {
53117       (arg1)->Insert(arg2,arg3,arg4);
53118     } catch (std::out_of_range& e) {
53119       {
53120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53121       };
53122     } catch (std::exception& e) {
53123       {
53124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53125       };
53126     } catch (Dali::DaliException e) {
53127       {
53128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53129       };
53130     } catch (...) {
53131       {
53132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53133       };
53134     }
53135   }
53136
53137 }
53138
53139
53140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53141   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53142   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53143
53144   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53145   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53146   {
53147     try {
53148       (arg1)->Reserve(arg2);
53149     } catch (std::out_of_range& e) {
53150       {
53151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53152       };
53153     } catch (std::exception& e) {
53154       {
53155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53156       };
53157     } catch (Dali::DaliException e) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53164       };
53165     }
53166   }
53167
53168 }
53169
53170
53171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53172   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53173   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53174
53175   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53176   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53177   {
53178     try {
53179       (arg1)->Resize(arg2);
53180     } catch (std::out_of_range& e) {
53181       {
53182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53183       };
53184     } catch (std::exception& e) {
53185       {
53186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53187       };
53188     } catch (Dali::DaliException e) {
53189       {
53190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53191       };
53192     } catch (...) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53195       };
53196     }
53197   }
53198
53199 }
53200
53201
53202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53203   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53204   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53205   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53206
53207   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53208   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53209   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53210   if (!arg3) {
53211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53212     return ;
53213   }
53214   {
53215     try {
53216       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53217     } catch (std::out_of_range& e) {
53218       {
53219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53220       };
53221     } catch (std::exception& e) {
53222       {
53223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (Dali::DaliException e) {
53226       {
53227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53228       };
53229     } catch (...) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53232       };
53233     }
53234   }
53235
53236 }
53237
53238
53239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53240   void * jresult ;
53241   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53242   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53243   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53244
53245   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53246   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53247   {
53248     try {
53249       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53250     } catch (std::out_of_range& e) {
53251       {
53252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53253       };
53254     } catch (std::exception& e) {
53255       {
53256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53257       };
53258     } catch (Dali::DaliException e) {
53259       {
53260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53261       };
53262     } catch (...) {
53263       {
53264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53265       };
53266     }
53267   }
53268
53269   jresult = (void *)result;
53270   return jresult;
53271 }
53272
53273
53274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53275   void * jresult ;
53276   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53277   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53278   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53279   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53280
53281   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53282   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53283   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53284   {
53285     try {
53286       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (Dali::DaliException e) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53298       };
53299     } catch (...) {
53300       {
53301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53302       };
53303     }
53304   }
53305
53306   jresult = (void *)result;
53307   return jresult;
53308 }
53309
53310
53311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53312   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53313   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53314
53315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53316   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53317   {
53318     try {
53319       (arg1)->Remove(arg2);
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (Dali::DaliException e) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53331       };
53332     } catch (...) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53335       };
53336     }
53337   }
53338
53339 }
53340
53341
53342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53343   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53344   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53345
53346   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53347   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53348   if (!arg2) {
53349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53350     return ;
53351   }
53352   {
53353     try {
53354       (arg1)->Swap(*arg2);
53355     } catch (std::out_of_range& e) {
53356       {
53357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (std::exception& e) {
53360       {
53361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53362       };
53363     } catch (Dali::DaliException e) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53366       };
53367     } catch (...) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53370       };
53371     }
53372   }
53373
53374 }
53375
53376
53377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53378   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53379
53380   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53381   {
53382     try {
53383       (arg1)->Clear();
53384     } catch (std::out_of_range& e) {
53385       {
53386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53387       };
53388     } catch (std::exception& e) {
53389       {
53390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (Dali::DaliException e) {
53393       {
53394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53395       };
53396     } catch (...) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53399       };
53400     }
53401   }
53402
53403 }
53404
53405
53406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53407   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53408
53409   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53410   {
53411     try {
53412       (arg1)->Release();
53413     } catch (std::out_of_range& e) {
53414       {
53415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53416       };
53417     } catch (std::exception& e) {
53418       {
53419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53420       };
53421     } catch (Dali::DaliException e) {
53422       {
53423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53424       };
53425     } catch (...) {
53426       {
53427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53428       };
53429     }
53430   }
53431
53432 }
53433
53434
53435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53436   void * jresult ;
53437   Dali::Signal< void () > *result = 0 ;
53438
53439   {
53440     try {
53441       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53442     } catch (std::out_of_range& e) {
53443       {
53444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53445       };
53446     } catch (std::exception& e) {
53447       {
53448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53449       };
53450     } catch (Dali::DaliException e) {
53451       {
53452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53453       };
53454     } catch (...) {
53455       {
53456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53457       };
53458     }
53459   }
53460
53461   jresult = (void *)result;
53462   return jresult;
53463 }
53464
53465
53466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53467   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53468
53469   arg1 = (Dali::Signal< void () > *)jarg1;
53470   {
53471     try {
53472       delete arg1;
53473     } catch (std::out_of_range& e) {
53474       {
53475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53476       };
53477     } catch (std::exception& e) {
53478       {
53479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53480       };
53481     } catch (Dali::DaliException e) {
53482       {
53483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53484       };
53485     } catch (...) {
53486       {
53487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53488       };
53489     }
53490   }
53491
53492 }
53493
53494
53495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53496   unsigned int jresult ;
53497   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53498   bool result;
53499
53500   arg1 = (Dali::Signal< void () > *)jarg1;
53501   {
53502     try {
53503       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53504     } catch (std::out_of_range& e) {
53505       {
53506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53507       };
53508     } catch (std::exception& e) {
53509       {
53510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53511       };
53512     } catch (Dali::DaliException e) {
53513       {
53514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53515       };
53516     } catch (...) {
53517       {
53518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53519       };
53520     }
53521   }
53522
53523   jresult = result;
53524   return jresult;
53525 }
53526
53527
53528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53529   unsigned long jresult ;
53530   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53531   std::size_t result;
53532
53533   arg1 = (Dali::Signal< void () > *)jarg1;
53534   {
53535     try {
53536       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53537     } catch (std::out_of_range& e) {
53538       {
53539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53540       };
53541     } catch (std::exception& e) {
53542       {
53543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53544       };
53545     } catch (Dali::DaliException e) {
53546       {
53547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53548       };
53549     } catch (...) {
53550       {
53551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53552       };
53553     }
53554   }
53555
53556   jresult = (unsigned long)result;
53557   return jresult;
53558 }
53559
53560
53561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53562   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53563   void (*arg2)() = (void (*)()) 0 ;
53564
53565   arg1 = (Dali::Signal< void () > *)jarg1;
53566   arg2 = (void (*)())jarg2;
53567   {
53568     try {
53569       (arg1)->Connect(arg2);
53570     } catch (std::out_of_range& e) {
53571       {
53572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53573       };
53574     } catch (std::exception& e) {
53575       {
53576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53577       };
53578     } catch (Dali::DaliException e) {
53579       {
53580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53581       };
53582     } catch (...) {
53583       {
53584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53585       };
53586     }
53587   }
53588
53589 }
53590
53591
53592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53593   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53594   void (*arg2)() = (void (*)()) 0 ;
53595
53596   arg1 = (Dali::Signal< void () > *)jarg1;
53597   arg2 = (void (*)())jarg2;
53598   {
53599     try {
53600       (arg1)->Disconnect(arg2);
53601     } catch (std::out_of_range& e) {
53602       {
53603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53604       };
53605     } catch (std::exception& e) {
53606       {
53607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (Dali::DaliException e) {
53610       {
53611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53612       };
53613     } catch (...) {
53614       {
53615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53616       };
53617     }
53618   }
53619
53620 }
53621
53622
53623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53624   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53625   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53626   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53627
53628   arg1 = (Dali::Signal< void () > *)jarg1;
53629   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53630   arg3 = (Dali::FunctorDelegate *)jarg3;
53631   {
53632     try {
53633       (arg1)->Connect(arg2,arg3);
53634     } catch (std::out_of_range& e) {
53635       {
53636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53637       };
53638     } catch (std::exception& e) {
53639       {
53640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53641       };
53642     } catch (Dali::DaliException e) {
53643       {
53644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53645       };
53646     } catch (...) {
53647       {
53648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53649       };
53650     }
53651   }
53652
53653 }
53654
53655
53656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53657   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53658
53659   arg1 = (Dali::Signal< void () > *)jarg1;
53660   {
53661     try {
53662       (arg1)->Emit();
53663     } catch (std::out_of_range& e) {
53664       {
53665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53666       };
53667     } catch (std::exception& e) {
53668       {
53669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53670       };
53671     } catch (Dali::DaliException e) {
53672       {
53673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53674       };
53675     } catch (...) {
53676       {
53677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53678       };
53679     }
53680   }
53681
53682 }
53683
53684
53685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53686   unsigned int jresult ;
53687   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53688   bool result;
53689
53690   arg1 = (Dali::Signal< void (float) > *)jarg1;
53691   {
53692     try {
53693       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53694     } catch (std::out_of_range& e) {
53695       {
53696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53697       };
53698     } catch (std::exception& e) {
53699       {
53700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53701       };
53702     } catch (Dali::DaliException e) {
53703       {
53704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53705       };
53706     } catch (...) {
53707       {
53708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53709       };
53710     }
53711   }
53712
53713   jresult = result;
53714   return jresult;
53715 }
53716
53717
53718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53719   unsigned long jresult ;
53720   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53721   std::size_t result;
53722
53723   arg1 = (Dali::Signal< void (float) > *)jarg1;
53724   {
53725     try {
53726       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53727     } catch (std::out_of_range& e) {
53728       {
53729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53730       };
53731     } catch (std::exception& e) {
53732       {
53733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53734       };
53735     } catch (Dali::DaliException e) {
53736       {
53737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53738       };
53739     } catch (...) {
53740       {
53741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53742       };
53743     }
53744   }
53745
53746   jresult = (unsigned long)result;
53747   return jresult;
53748 }
53749
53750
53751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53752   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53753   void (*arg2)(float) = (void (*)(float)) 0 ;
53754
53755   arg1 = (Dali::Signal< void (float) > *)jarg1;
53756   arg2 = (void (*)(float))jarg2;
53757   {
53758     try {
53759       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53760     } catch (std::out_of_range& e) {
53761       {
53762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53763       };
53764     } catch (std::exception& e) {
53765       {
53766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53767       };
53768     } catch (Dali::DaliException e) {
53769       {
53770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53771       };
53772     } catch (...) {
53773       {
53774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53775       };
53776     }
53777   }
53778
53779 }
53780
53781
53782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53783   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53784   void (*arg2)(float) = (void (*)(float)) 0 ;
53785
53786   arg1 = (Dali::Signal< void (float) > *)jarg1;
53787   arg2 = (void (*)(float))jarg2;
53788   {
53789     try {
53790       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53791     } catch (std::out_of_range& e) {
53792       {
53793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53794       };
53795     } catch (std::exception& e) {
53796       {
53797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53798       };
53799     } catch (Dali::DaliException e) {
53800       {
53801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53802       };
53803     } catch (...) {
53804       {
53805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53806       };
53807     }
53808   }
53809
53810 }
53811
53812
53813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53814   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53815   float arg2 ;
53816
53817   arg1 = (Dali::Signal< void (float) > *)jarg1;
53818   arg2 = (float)jarg2;
53819   {
53820     try {
53821       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53822     } catch (std::out_of_range& e) {
53823       {
53824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53825       };
53826     } catch (std::exception& e) {
53827       {
53828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53829       };
53830     } catch (Dali::DaliException e) {
53831       {
53832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53833       };
53834     } catch (...) {
53835       {
53836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53837       };
53838     }
53839   }
53840
53841 }
53842
53843
53844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
53845   void * jresult ;
53846   Dali::Signal< void (float) > *result = 0 ;
53847
53848   {
53849     try {
53850       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
53851     } catch (std::out_of_range& e) {
53852       {
53853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53854       };
53855     } catch (std::exception& e) {
53856       {
53857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (Dali::DaliException e) {
53860       {
53861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53862       };
53863     } catch (...) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53866       };
53867     }
53868   }
53869
53870   jresult = (void *)result;
53871   return jresult;
53872 }
53873
53874
53875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
53876   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53877
53878   arg1 = (Dali::Signal< void (float) > *)jarg1;
53879   {
53880     try {
53881       delete arg1;
53882     } catch (std::out_of_range& e) {
53883       {
53884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53885       };
53886     } catch (std::exception& e) {
53887       {
53888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53889       };
53890     } catch (Dali::DaliException e) {
53891       {
53892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53893       };
53894     } catch (...) {
53895       {
53896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53897       };
53898     }
53899   }
53900
53901 }
53902
53903
53904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
53905   unsigned int jresult ;
53906   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53907   bool result;
53908
53909   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53910   {
53911     try {
53912       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53913     } catch (std::out_of_range& e) {
53914       {
53915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53916       };
53917     } catch (std::exception& e) {
53918       {
53919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53920       };
53921     } catch (Dali::DaliException e) {
53922       {
53923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53924       };
53925     } catch (...) {
53926       {
53927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53928       };
53929     }
53930   }
53931
53932   jresult = result;
53933   return jresult;
53934 }
53935
53936
53937 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
53938   unsigned long jresult ;
53939   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53940   std::size_t result;
53941
53942   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53943   {
53944     try {
53945       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53946     } catch (std::out_of_range& e) {
53947       {
53948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53949       };
53950     } catch (std::exception& e) {
53951       {
53952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53953       };
53954     } catch (Dali::DaliException e) {
53955       {
53956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53957       };
53958     } catch (...) {
53959       {
53960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53961       };
53962     }
53963   }
53964
53965   jresult = (unsigned long)result;
53966   return jresult;
53967 }
53968
53969
53970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
53971   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53972   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
53973
53974   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53975   arg2 = (void (*)(Dali::BaseHandle))jarg2;
53976   {
53977     try {
53978       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
53979     } catch (std::out_of_range& e) {
53980       {
53981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53982       };
53983     } catch (std::exception& e) {
53984       {
53985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53986       };
53987     } catch (Dali::DaliException e) {
53988       {
53989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53990       };
53991     } catch (...) {
53992       {
53993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53994       };
53995     }
53996   }
53997
53998 }
53999
54000
54001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54002   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54003   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54004
54005   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54006   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54007   {
54008     try {
54009       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54010     } catch (std::out_of_range& e) {
54011       {
54012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54013       };
54014     } catch (std::exception& e) {
54015       {
54016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54017       };
54018     } catch (Dali::DaliException e) {
54019       {
54020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54021       };
54022     } catch (...) {
54023       {
54024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54025       };
54026     }
54027   }
54028
54029 }
54030
54031
54032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54033   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54034   Dali::BaseHandle arg2 ;
54035   Dali::BaseHandle *argp2 ;
54036
54037   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54038   argp2 = (Dali::BaseHandle *)jarg2;
54039   if (!argp2) {
54040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54041     return ;
54042   }
54043   arg2 = *argp2;
54044   {
54045     try {
54046       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54047     } catch (std::out_of_range& e) {
54048       {
54049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54050       };
54051     } catch (std::exception& e) {
54052       {
54053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54054       };
54055     } catch (Dali::DaliException e) {
54056       {
54057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54058       };
54059     } catch (...) {
54060       {
54061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54062       };
54063     }
54064   }
54065
54066 }
54067
54068
54069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54070   void * jresult ;
54071   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54072
54073   {
54074     try {
54075       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54076     } catch (std::out_of_range& e) {
54077       {
54078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54079       };
54080     } catch (std::exception& e) {
54081       {
54082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54083       };
54084     } catch (Dali::DaliException e) {
54085       {
54086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54087       };
54088     } catch (...) {
54089       {
54090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54091       };
54092     }
54093   }
54094
54095   jresult = (void *)result;
54096   return jresult;
54097 }
54098
54099
54100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54101   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54102
54103   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54104   {
54105     try {
54106       delete arg1;
54107     } catch (std::out_of_range& e) {
54108       {
54109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54110       };
54111     } catch (std::exception& e) {
54112       {
54113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54114       };
54115     } catch (Dali::DaliException e) {
54116       {
54117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54118       };
54119     } catch (...) {
54120       {
54121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54122       };
54123     }
54124   }
54125
54126 }
54127
54128
54129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54130   unsigned int jresult ;
54131   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54132   bool result;
54133
54134   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54135   {
54136     try {
54137       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54138     } catch (std::out_of_range& e) {
54139       {
54140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54141       };
54142     } catch (std::exception& e) {
54143       {
54144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54145       };
54146     } catch (Dali::DaliException e) {
54147       {
54148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54149       };
54150     } catch (...) {
54151       {
54152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54153       };
54154     }
54155   }
54156
54157   jresult = result;
54158   return jresult;
54159 }
54160
54161
54162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54163   unsigned long jresult ;
54164   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54165   std::size_t result;
54166
54167   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54168   {
54169     try {
54170       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54171     } catch (std::out_of_range& e) {
54172       {
54173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54174       };
54175     } catch (std::exception& e) {
54176       {
54177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54178       };
54179     } catch (Dali::DaliException e) {
54180       {
54181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54182       };
54183     } catch (...) {
54184       {
54185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54186       };
54187     }
54188   }
54189
54190   jresult = (unsigned long)result;
54191   return jresult;
54192 }
54193
54194
54195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54196   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54197   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54198
54199   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54200   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54201   {
54202     try {
54203       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54204     } catch (std::out_of_range& e) {
54205       {
54206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54207       };
54208     } catch (std::exception& e) {
54209       {
54210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54211       };
54212     } catch (Dali::DaliException e) {
54213       {
54214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54215       };
54216     } catch (...) {
54217       {
54218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54219       };
54220     }
54221   }
54222
54223 }
54224
54225
54226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54227   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54228   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54229
54230   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54231   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54232   {
54233     try {
54234       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54235     } catch (std::out_of_range& e) {
54236       {
54237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54238       };
54239     } catch (std::exception& e) {
54240       {
54241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54242       };
54243     } catch (Dali::DaliException e) {
54244       {
54245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54246       };
54247     } catch (...) {
54248       {
54249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54250       };
54251     }
54252   }
54253
54254 }
54255
54256
54257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54258   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54259   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54260
54261   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54262   arg2 = (Dali::RefObject *)jarg2;
54263   {
54264     try {
54265       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54266     } catch (std::out_of_range& e) {
54267       {
54268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54269       };
54270     } catch (std::exception& e) {
54271       {
54272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54273       };
54274     } catch (Dali::DaliException e) {
54275       {
54276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54277       };
54278     } catch (...) {
54279       {
54280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54281       };
54282     }
54283   }
54284
54285 }
54286
54287
54288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54289   void * jresult ;
54290   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54291
54292   {
54293     try {
54294       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54295     } catch (std::out_of_range& e) {
54296       {
54297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54298       };
54299     } catch (std::exception& e) {
54300       {
54301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54302       };
54303     } catch (Dali::DaliException e) {
54304       {
54305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54306       };
54307     } catch (...) {
54308       {
54309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54310       };
54311     }
54312   }
54313
54314   jresult = (void *)result;
54315   return jresult;
54316 }
54317
54318
54319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54320   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54321
54322   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54323   {
54324     try {
54325       delete arg1;
54326     } catch (std::out_of_range& e) {
54327       {
54328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54329       };
54330     } catch (std::exception& e) {
54331       {
54332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54333       };
54334     } catch (Dali::DaliException e) {
54335       {
54336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54337       };
54338     } catch (...) {
54339       {
54340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54341       };
54342     }
54343   }
54344
54345 }
54346
54347
54348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54349   unsigned int jresult ;
54350   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54351   bool result;
54352
54353   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54354   {
54355     try {
54356       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54357     } catch (std::out_of_range& e) {
54358       {
54359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54360       };
54361     } catch (std::exception& e) {
54362       {
54363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54364       };
54365     } catch (Dali::DaliException e) {
54366       {
54367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54368       };
54369     } catch (...) {
54370       {
54371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54372       };
54373     }
54374   }
54375
54376   jresult = result;
54377   return jresult;
54378 }
54379
54380
54381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54382   unsigned long jresult ;
54383   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54384   std::size_t result;
54385
54386   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54387   {
54388     try {
54389       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54390     } catch (std::out_of_range& e) {
54391       {
54392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54393       };
54394     } catch (std::exception& e) {
54395       {
54396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54397       };
54398     } catch (Dali::DaliException e) {
54399       {
54400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54401       };
54402     } catch (...) {
54403       {
54404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54405       };
54406     }
54407   }
54408
54409   jresult = (unsigned long)result;
54410   return jresult;
54411 }
54412
54413
54414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54415   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54416   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54417
54418   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54419   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54420   {
54421     try {
54422       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54423     } catch (std::out_of_range& e) {
54424       {
54425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54426       };
54427     } catch (std::exception& e) {
54428       {
54429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54430       };
54431     } catch (Dali::DaliException e) {
54432       {
54433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54434       };
54435     } catch (...) {
54436       {
54437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54438       };
54439     }
54440   }
54441
54442 }
54443
54444
54445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54446   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54447   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54448
54449   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54450   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54451   {
54452     try {
54453       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54454     } catch (std::out_of_range& e) {
54455       {
54456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54457       };
54458     } catch (std::exception& e) {
54459       {
54460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54461       };
54462     } catch (Dali::DaliException e) {
54463       {
54464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54465       };
54466     } catch (...) {
54467       {
54468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54469       };
54470     }
54471   }
54472
54473 }
54474
54475
54476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54477   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54478   Dali::PropertyNotification *arg2 = 0 ;
54479
54480   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54481   arg2 = (Dali::PropertyNotification *)jarg2;
54482   if (!arg2) {
54483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54484     return ;
54485   }
54486   {
54487     try {
54488       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54489     } catch (std::out_of_range& e) {
54490       {
54491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54492       };
54493     } catch (std::exception& e) {
54494       {
54495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54496       };
54497     } catch (Dali::DaliException e) {
54498       {
54499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54500       };
54501     } catch (...) {
54502       {
54503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54504       };
54505     }
54506   }
54507
54508 }
54509
54510
54511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54512   void * jresult ;
54513   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54514
54515   {
54516     try {
54517       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54518     } catch (std::out_of_range& e) {
54519       {
54520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54521       };
54522     } catch (std::exception& e) {
54523       {
54524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54525       };
54526     } catch (Dali::DaliException e) {
54527       {
54528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54529       };
54530     } catch (...) {
54531       {
54532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54533       };
54534     }
54535   }
54536
54537   jresult = (void *)result;
54538   return jresult;
54539 }
54540
54541
54542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54543   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54544
54545   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54546   {
54547     try {
54548       delete arg1;
54549     } catch (std::out_of_range& e) {
54550       {
54551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54552       };
54553     } catch (std::exception& e) {
54554       {
54555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54556       };
54557     } catch (Dali::DaliException e) {
54558       {
54559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54560       };
54561     } catch (...) {
54562       {
54563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54564       };
54565     }
54566   }
54567
54568 }
54569
54570
54571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54572   unsigned int jresult ;
54573   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54574   bool result;
54575
54576   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54577   {
54578     try {
54579       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54580     } catch (std::out_of_range& e) {
54581       {
54582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54583       };
54584     } catch (std::exception& e) {
54585       {
54586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54587       };
54588     } catch (Dali::DaliException e) {
54589       {
54590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54591       };
54592     } catch (...) {
54593       {
54594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54595       };
54596     }
54597   }
54598
54599   jresult = result;
54600   return jresult;
54601 }
54602
54603
54604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54605   unsigned long jresult ;
54606   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54607   std::size_t result;
54608
54609   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54610   {
54611     try {
54612       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54613     } catch (std::out_of_range& e) {
54614       {
54615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54616       };
54617     } catch (std::exception& e) {
54618       {
54619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54620       };
54621     } catch (Dali::DaliException e) {
54622       {
54623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54624       };
54625     } catch (...) {
54626       {
54627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54628       };
54629     }
54630   }
54631
54632   jresult = (unsigned long)result;
54633   return jresult;
54634 }
54635
54636
54637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54638   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54639   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54640
54641   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54642   arg2 = (void (*)(Dali::Image))jarg2;
54643   {
54644     try {
54645       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54646     } catch (std::out_of_range& e) {
54647       {
54648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54649       };
54650     } catch (std::exception& e) {
54651       {
54652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54653       };
54654     } catch (Dali::DaliException e) {
54655       {
54656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54657       };
54658     } catch (...) {
54659       {
54660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54661       };
54662     }
54663   }
54664
54665 }
54666
54667
54668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54669   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54670   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54671
54672   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54673   arg2 = (void (*)(Dali::Image))jarg2;
54674   {
54675     try {
54676       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54677     } catch (std::out_of_range& e) {
54678       {
54679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54680       };
54681     } catch (std::exception& e) {
54682       {
54683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54684       };
54685     } catch (Dali::DaliException e) {
54686       {
54687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54688       };
54689     } catch (...) {
54690       {
54691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54692       };
54693     }
54694   }
54695
54696 }
54697
54698
54699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54700   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54701   Dali::Image arg2 ;
54702   Dali::Image *argp2 ;
54703
54704   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54705   argp2 = (Dali::Image *)jarg2;
54706   if (!argp2) {
54707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54708     return ;
54709   }
54710   arg2 = *argp2;
54711   {
54712     try {
54713       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54714     } catch (std::out_of_range& e) {
54715       {
54716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54717       };
54718     } catch (std::exception& e) {
54719       {
54720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54721       };
54722     } catch (Dali::DaliException e) {
54723       {
54724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54725       };
54726     } catch (...) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54729       };
54730     }
54731   }
54732
54733 }
54734
54735
54736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54737   void * jresult ;
54738   Dali::Signal< void (Dali::Image) > *result = 0 ;
54739
54740   {
54741     try {
54742       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54743     } catch (std::out_of_range& e) {
54744       {
54745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54746       };
54747     } catch (std::exception& e) {
54748       {
54749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (Dali::DaliException e) {
54752       {
54753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54754       };
54755     } catch (...) {
54756       {
54757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54758       };
54759     }
54760   }
54761
54762   jresult = (void *)result;
54763   return jresult;
54764 }
54765
54766
54767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54768   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54769
54770   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54771   {
54772     try {
54773       delete arg1;
54774     } catch (std::out_of_range& e) {
54775       {
54776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54777       };
54778     } catch (std::exception& e) {
54779       {
54780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54781       };
54782     } catch (Dali::DaliException e) {
54783       {
54784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54785       };
54786     } catch (...) {
54787       {
54788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54789       };
54790     }
54791   }
54792
54793 }
54794
54795
54796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54797   void * jresult ;
54798   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54799
54800   {
54801     try {
54802       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54803     } catch (std::out_of_range& e) {
54804       {
54805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54806       };
54807     } catch (std::exception& e) {
54808       {
54809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54810       };
54811     } catch (Dali::DaliException e) {
54812       {
54813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54814       };
54815     } catch (...) {
54816       {
54817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54818       };
54819     }
54820   }
54821
54822   jresult = (void *)result;
54823   return jresult;
54824 }
54825
54826
54827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54828   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54829
54830   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
54831   {
54832     try {
54833       delete arg1;
54834     } catch (std::out_of_range& e) {
54835       {
54836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54837       };
54838     } catch (std::exception& e) {
54839       {
54840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54841       };
54842     } catch (Dali::DaliException e) {
54843       {
54844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54845       };
54846     } catch (...) {
54847       {
54848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54849       };
54850     }
54851   }
54852
54853 }
54854
54855
54856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
54857   unsigned int jresult ;
54858   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54859   bool result;
54860
54861   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54862   {
54863     try {
54864       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);
54865     } catch (std::out_of_range& e) {
54866       {
54867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54868       };
54869     } catch (std::exception& e) {
54870       {
54871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54872       };
54873     } catch (Dali::DaliException e) {
54874       {
54875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54876       };
54877     } catch (...) {
54878       {
54879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54880       };
54881     }
54882   }
54883
54884   jresult = result;
54885   return jresult;
54886 }
54887
54888
54889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54890   unsigned long jresult ;
54891   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54892   std::size_t result;
54893
54894   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54895   {
54896     try {
54897       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);
54898     } catch (std::out_of_range& e) {
54899       {
54900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54901       };
54902     } catch (std::exception& e) {
54903       {
54904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54905       };
54906     } catch (Dali::DaliException e) {
54907       {
54908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54909       };
54910     } catch (...) {
54911       {
54912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54913       };
54914     }
54915   }
54916
54917   jresult = (unsigned long)result;
54918   return jresult;
54919 }
54920
54921
54922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54923   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54924   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54925
54926   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54927   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54928   {
54929     try {
54930       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54931     } catch (std::out_of_range& e) {
54932       {
54933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54934       };
54935     } catch (std::exception& e) {
54936       {
54937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54938       };
54939     } catch (Dali::DaliException e) {
54940       {
54941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54942       };
54943     } catch (...) {
54944       {
54945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54946       };
54947     }
54948   }
54949
54950 }
54951
54952
54953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54954   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54955   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54956
54957   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54958   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54959   {
54960     try {
54961       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54962     } catch (std::out_of_range& e) {
54963       {
54964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54965       };
54966     } catch (std::exception& e) {
54967       {
54968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54969       };
54970     } catch (Dali::DaliException e) {
54971       {
54972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54973       };
54974     } catch (...) {
54975       {
54976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54977       };
54978     }
54979   }
54980
54981 }
54982
54983
54984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54985   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54986   Dali::Actor arg2 ;
54987   Dali::LongPressGesture *arg3 = 0 ;
54988   Dali::Actor *argp2 ;
54989
54990   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54991   argp2 = (Dali::Actor *)jarg2;
54992   if (!argp2) {
54993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54994     return ;
54995   }
54996   arg2 = *argp2;
54997   arg3 = (Dali::LongPressGesture *)jarg3;
54998   if (!arg3) {
54999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55000     return ;
55001   }
55002   {
55003     try {
55004       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
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_LongPressGestureDetectedSignal() {
55028   void * jresult ;
55029   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55030
55031   {
55032     try {
55033       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
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_delete_LongPressGestureDetectedSignal(void * jarg1) {
55059   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55060
55061   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55062   {
55063     try {
55064       delete arg1;
55065     } catch (std::out_of_range& e) {
55066       {
55067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55068       };
55069     } catch (std::exception& e) {
55070       {
55071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55072       };
55073     } catch (Dali::DaliException e) {
55074       {
55075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55076       };
55077     } catch (...) {
55078       {
55079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55080       };
55081     }
55082   }
55083
55084 }
55085
55086
55087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55088   unsigned int jresult ;
55089   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55090   bool result;
55091
55092   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55093   {
55094     try {
55095       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);
55096     } catch (std::out_of_range& e) {
55097       {
55098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55099       };
55100     } catch (std::exception& e) {
55101       {
55102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55103       };
55104     } catch (Dali::DaliException e) {
55105       {
55106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55107       };
55108     } catch (...) {
55109       {
55110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55111       };
55112     }
55113   }
55114
55115   jresult = result;
55116   return jresult;
55117 }
55118
55119
55120 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55121   unsigned long jresult ;
55122   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55123   std::size_t result;
55124
55125   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55126   {
55127     try {
55128       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);
55129     } catch (std::out_of_range& e) {
55130       {
55131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55132       };
55133     } catch (std::exception& e) {
55134       {
55135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55136       };
55137     } catch (Dali::DaliException e) {
55138       {
55139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55140       };
55141     } catch (...) {
55142       {
55143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55144       };
55145     }
55146   }
55147
55148   jresult = (unsigned long)result;
55149   return jresult;
55150 }
55151
55152
55153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55154   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55155   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55156
55157   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55158   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55159   {
55160     try {
55161       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55162     } catch (std::out_of_range& e) {
55163       {
55164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55165       };
55166     } catch (std::exception& e) {
55167       {
55168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55169       };
55170     } catch (Dali::DaliException e) {
55171       {
55172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55173       };
55174     } catch (...) {
55175       {
55176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55177       };
55178     }
55179   }
55180
55181 }
55182
55183
55184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55185   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55186   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55187
55188   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55189   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55190   {
55191     try {
55192       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55193     } catch (std::out_of_range& e) {
55194       {
55195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55196       };
55197     } catch (std::exception& e) {
55198       {
55199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55200       };
55201     } catch (Dali::DaliException e) {
55202       {
55203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55204       };
55205     } catch (...) {
55206       {
55207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55208       };
55209     }
55210   }
55211
55212 }
55213
55214
55215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55216   unsigned int jresult ;
55217   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55218   Dali::Actor arg2 ;
55219   Dali::TouchData *arg3 = 0 ;
55220   Dali::Actor *argp2 ;
55221   bool result;
55222
55223   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55224   argp2 = (Dali::Actor *)jarg2;
55225   if (!argp2) {
55226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55227     return 0;
55228   }
55229   arg2 = *argp2;
55230   arg3 = (Dali::TouchData *)jarg3;
55231   if (!arg3) {
55232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55233     return 0;
55234   }
55235   {
55236     try {
55237       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55238     } catch (std::out_of_range& e) {
55239       {
55240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55241       };
55242     } catch (std::exception& e) {
55243       {
55244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55245       };
55246     } catch (Dali::DaliException e) {
55247       {
55248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55249       };
55250     } catch (...) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55253       };
55254     }
55255   }
55256
55257   jresult = result;
55258   return jresult;
55259 }
55260
55261
55262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55263   void * jresult ;
55264   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55265
55266   {
55267     try {
55268       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55269     } catch (std::out_of_range& e) {
55270       {
55271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55272       };
55273     } catch (std::exception& e) {
55274       {
55275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55276       };
55277     } catch (Dali::DaliException e) {
55278       {
55279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55280       };
55281     } catch (...) {
55282       {
55283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55284       };
55285     }
55286   }
55287
55288   jresult = (void *)result;
55289   return jresult;
55290 }
55291
55292
55293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55294   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55295
55296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55297   {
55298     try {
55299       delete arg1;
55300     } catch (std::out_of_range& e) {
55301       {
55302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55303       };
55304     } catch (std::exception& e) {
55305       {
55306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55307       };
55308     } catch (Dali::DaliException e) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55315       };
55316     }
55317   }
55318
55319 }
55320
55321
55322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55323   unsigned int jresult ;
55324   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55325   bool result;
55326
55327   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55328   {
55329     try {
55330       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);
55331     } catch (std::out_of_range& e) {
55332       {
55333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55334       };
55335     } catch (std::exception& e) {
55336       {
55337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55338       };
55339     } catch (Dali::DaliException e) {
55340       {
55341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55342       };
55343     } catch (...) {
55344       {
55345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55346       };
55347     }
55348   }
55349
55350   jresult = result;
55351   return jresult;
55352 }
55353
55354
55355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55356   unsigned long jresult ;
55357   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55358   std::size_t result;
55359
55360   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55361   {
55362     try {
55363       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);
55364     } catch (std::out_of_range& e) {
55365       {
55366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55367       };
55368     } catch (std::exception& e) {
55369       {
55370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55371       };
55372     } catch (Dali::DaliException e) {
55373       {
55374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55375       };
55376     } catch (...) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55379       };
55380     }
55381   }
55382
55383   jresult = (unsigned long)result;
55384   return jresult;
55385 }
55386
55387
55388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55389   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55390   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55391
55392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55393   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55394   {
55395     try {
55396       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55397     } catch (std::out_of_range& e) {
55398       {
55399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55400       };
55401     } catch (std::exception& e) {
55402       {
55403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55404       };
55405     } catch (Dali::DaliException e) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55408       };
55409     } catch (...) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55412       };
55413     }
55414   }
55415
55416 }
55417
55418
55419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55420   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55421   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55422
55423   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55424   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55425   {
55426     try {
55427       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55428     } catch (std::out_of_range& e) {
55429       {
55430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55431       };
55432     } catch (std::exception& e) {
55433       {
55434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55435       };
55436     } catch (Dali::DaliException e) {
55437       {
55438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55439       };
55440     } catch (...) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55443       };
55444     }
55445   }
55446
55447 }
55448
55449
55450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55451   unsigned int jresult ;
55452   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55453   Dali::Actor arg2 ;
55454   Dali::HoverEvent *arg3 = 0 ;
55455   Dali::Actor *argp2 ;
55456   bool result;
55457
55458   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55459   argp2 = (Dali::Actor *)jarg2;
55460   if (!argp2) {
55461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55462     return 0;
55463   }
55464   arg2 = *argp2;
55465   arg3 = (Dali::HoverEvent *)jarg3;
55466   if (!arg3) {
55467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55468     return 0;
55469   }
55470   {
55471     try {
55472       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55473     } catch (std::out_of_range& e) {
55474       {
55475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55476       };
55477     } catch (std::exception& e) {
55478       {
55479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55480       };
55481     } catch (Dali::DaliException e) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55484       };
55485     } catch (...) {
55486       {
55487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55488       };
55489     }
55490   }
55491
55492   jresult = result;
55493   return jresult;
55494 }
55495
55496
55497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55498   void * jresult ;
55499   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55500
55501   {
55502     try {
55503       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55504     } catch (std::out_of_range& e) {
55505       {
55506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55507       };
55508     } catch (std::exception& e) {
55509       {
55510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55511       };
55512     } catch (Dali::DaliException e) {
55513       {
55514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55515       };
55516     } catch (...) {
55517       {
55518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55519       };
55520     }
55521   }
55522
55523   jresult = (void *)result;
55524   return jresult;
55525 }
55526
55527
55528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55529   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55530
55531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55532   {
55533     try {
55534       delete arg1;
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55542       };
55543     } catch (Dali::DaliException e) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55546       };
55547     } catch (...) {
55548       {
55549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55550       };
55551     }
55552   }
55553
55554 }
55555
55556
55557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55558   unsigned int jresult ;
55559   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55560   bool result;
55561
55562   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55563   {
55564     try {
55565       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);
55566     } catch (std::out_of_range& e) {
55567       {
55568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55569       };
55570     } catch (std::exception& e) {
55571       {
55572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55573       };
55574     } catch (Dali::DaliException e) {
55575       {
55576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55577       };
55578     } catch (...) {
55579       {
55580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55581       };
55582     }
55583   }
55584
55585   jresult = result;
55586   return jresult;
55587 }
55588
55589
55590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55591   unsigned long jresult ;
55592   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55593   std::size_t result;
55594
55595   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55596   {
55597     try {
55598       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);
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55606       };
55607     } catch (Dali::DaliException e) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55610       };
55611     } catch (...) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55614       };
55615     }
55616   }
55617
55618   jresult = (unsigned long)result;
55619   return jresult;
55620 }
55621
55622
55623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55624   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55625   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55626
55627   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55628   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55629   {
55630     try {
55631       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55632     } catch (std::out_of_range& e) {
55633       {
55634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55635       };
55636     } catch (std::exception& e) {
55637       {
55638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55639       };
55640     } catch (Dali::DaliException e) {
55641       {
55642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55643       };
55644     } catch (...) {
55645       {
55646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55647       };
55648     }
55649   }
55650
55651 }
55652
55653
55654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55655   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55656   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55657
55658   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55659   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55660   {
55661     try {
55662       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55663     } catch (std::out_of_range& e) {
55664       {
55665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55666       };
55667     } catch (std::exception& e) {
55668       {
55669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55670       };
55671     } catch (Dali::DaliException e) {
55672       {
55673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55674       };
55675     } catch (...) {
55676       {
55677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55678       };
55679     }
55680   }
55681
55682 }
55683
55684
55685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55686   unsigned int jresult ;
55687   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55688   Dali::Actor arg2 ;
55689   Dali::WheelEvent *arg3 = 0 ;
55690   Dali::Actor *argp2 ;
55691   bool result;
55692
55693   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55694   argp2 = (Dali::Actor *)jarg2;
55695   if (!argp2) {
55696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55697     return 0;
55698   }
55699   arg2 = *argp2;
55700   arg3 = (Dali::WheelEvent *)jarg3;
55701   if (!arg3) {
55702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55703     return 0;
55704   }
55705   {
55706     try {
55707       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55708     } catch (std::out_of_range& e) {
55709       {
55710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55711       };
55712     } catch (std::exception& e) {
55713       {
55714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55715       };
55716     } catch (Dali::DaliException e) {
55717       {
55718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55719       };
55720     } catch (...) {
55721       {
55722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55723       };
55724     }
55725   }
55726
55727   jresult = result;
55728   return jresult;
55729 }
55730
55731
55732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55733   void * jresult ;
55734   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55735
55736   {
55737     try {
55738       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55739     } catch (std::out_of_range& e) {
55740       {
55741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (std::exception& e) {
55744       {
55745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (Dali::DaliException e) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55750       };
55751     } catch (...) {
55752       {
55753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55754       };
55755     }
55756   }
55757
55758   jresult = (void *)result;
55759   return jresult;
55760 }
55761
55762
55763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55764   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55765
55766   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55767   {
55768     try {
55769       delete arg1;
55770     } catch (std::out_of_range& e) {
55771       {
55772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55773       };
55774     } catch (std::exception& e) {
55775       {
55776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55777       };
55778     } catch (Dali::DaliException e) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55781       };
55782     } catch (...) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55785       };
55786     }
55787   }
55788
55789 }
55790
55791
55792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55793   unsigned int jresult ;
55794   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55795   bool result;
55796
55797   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55798   {
55799     try {
55800       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55801     } catch (std::out_of_range& e) {
55802       {
55803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55804       };
55805     } catch (std::exception& e) {
55806       {
55807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55808       };
55809     } catch (Dali::DaliException e) {
55810       {
55811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55812       };
55813     } catch (...) {
55814       {
55815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55816       };
55817     }
55818   }
55819
55820   jresult = result;
55821   return jresult;
55822 }
55823
55824
55825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55826   unsigned long jresult ;
55827   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55828   std::size_t result;
55829
55830   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55831   {
55832     try {
55833       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55841       };
55842     } catch (Dali::DaliException e) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55845       };
55846     } catch (...) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55849       };
55850     }
55851   }
55852
55853   jresult = (unsigned long)result;
55854   return jresult;
55855 }
55856
55857
55858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
55859   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55860   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55861
55862   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55863   arg2 = (void (*)(Dali::Actor))jarg2;
55864   {
55865     try {
55866       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55867     } catch (std::out_of_range& e) {
55868       {
55869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55870       };
55871     } catch (std::exception& e) {
55872       {
55873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55874       };
55875     } catch (Dali::DaliException e) {
55876       {
55877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55878       };
55879     } catch (...) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55882       };
55883     }
55884   }
55885
55886 }
55887
55888
55889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
55890   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55891   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55892
55893   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55894   arg2 = (void (*)(Dali::Actor))jarg2;
55895   {
55896     try {
55897       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55898     } catch (std::out_of_range& e) {
55899       {
55900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55901       };
55902     } catch (std::exception& e) {
55903       {
55904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55905       };
55906     } catch (Dali::DaliException e) {
55907       {
55908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55909       };
55910     } catch (...) {
55911       {
55912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55913       };
55914     }
55915   }
55916
55917 }
55918
55919
55920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
55921   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55922   Dali::Actor arg2 ;
55923   Dali::Actor *argp2 ;
55924
55925   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55926   argp2 = (Dali::Actor *)jarg2;
55927   if (!argp2) {
55928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55929     return ;
55930   }
55931   arg2 = *argp2;
55932   {
55933     try {
55934       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
55935     } catch (std::out_of_range& e) {
55936       {
55937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55938       };
55939     } catch (std::exception& e) {
55940       {
55941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55942       };
55943     } catch (Dali::DaliException e) {
55944       {
55945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55946       };
55947     } catch (...) {
55948       {
55949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55950       };
55951     }
55952   }
55953
55954 }
55955
55956
55957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
55958   void * jresult ;
55959   Dali::Signal< void (Dali::Actor) > *result = 0 ;
55960
55961   {
55962     try {
55963       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
55964     } catch (std::out_of_range& e) {
55965       {
55966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55967       };
55968     } catch (std::exception& e) {
55969       {
55970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55971       };
55972     } catch (Dali::DaliException e) {
55973       {
55974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55975       };
55976     } catch (...) {
55977       {
55978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55979       };
55980     }
55981   }
55982
55983   jresult = (void *)result;
55984   return jresult;
55985 }
55986
55987
55988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
55989   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55990
55991   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55992   {
55993     try {
55994       delete arg1;
55995     } catch (std::out_of_range& e) {
55996       {
55997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55998       };
55999     } catch (std::exception& e) {
56000       {
56001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56002       };
56003     } catch (Dali::DaliException e) {
56004       {
56005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56006       };
56007     } catch (...) {
56008       {
56009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56010       };
56011     }
56012   }
56013
56014 }
56015
56016
56017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56018   unsigned int jresult ;
56019   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56020   bool result;
56021
56022   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56023   {
56024     try {
56025       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56026     } catch (std::out_of_range& e) {
56027       {
56028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (std::exception& e) {
56031       {
56032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56033       };
56034     } catch (Dali::DaliException e) {
56035       {
56036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56037       };
56038     } catch (...) {
56039       {
56040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56041       };
56042     }
56043   }
56044
56045   jresult = result;
56046   return jresult;
56047 }
56048
56049
56050 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56051   unsigned long jresult ;
56052   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56053   std::size_t result;
56054
56055   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56056   {
56057     try {
56058       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56059     } catch (std::out_of_range& e) {
56060       {
56061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56062       };
56063     } catch (std::exception& e) {
56064       {
56065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56066       };
56067     } catch (Dali::DaliException e) {
56068       {
56069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56070       };
56071     } catch (...) {
56072       {
56073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56074       };
56075     }
56076   }
56077
56078   jresult = (unsigned long)result;
56079   return jresult;
56080 }
56081
56082
56083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56084   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56085   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56086
56087   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56088   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56089   {
56090     try {
56091       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56092     } catch (std::out_of_range& e) {
56093       {
56094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56095       };
56096     } catch (std::exception& e) {
56097       {
56098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56099       };
56100     } catch (Dali::DaliException e) {
56101       {
56102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56103       };
56104     } catch (...) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56107       };
56108     }
56109   }
56110
56111 }
56112
56113
56114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56115   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56116   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56117
56118   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56119   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56120   {
56121     try {
56122       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56123     } catch (std::out_of_range& e) {
56124       {
56125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56126       };
56127     } catch (std::exception& e) {
56128       {
56129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56130       };
56131     } catch (Dali::DaliException e) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56134       };
56135     } catch (...) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56138       };
56139     }
56140   }
56141
56142 }
56143
56144
56145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56146   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56147   Dali::KeyEvent *arg2 = 0 ;
56148
56149   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56150   arg2 = (Dali::KeyEvent *)jarg2;
56151   if (!arg2) {
56152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56153     return ;
56154   }
56155   {
56156     try {
56157       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56158     } catch (std::out_of_range& e) {
56159       {
56160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56161       };
56162     } catch (std::exception& e) {
56163       {
56164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56165       };
56166     } catch (Dali::DaliException e) {
56167       {
56168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56169       };
56170     } catch (...) {
56171       {
56172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56173       };
56174     }
56175   }
56176
56177 }
56178
56179
56180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56181   void * jresult ;
56182   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56183
56184   {
56185     try {
56186       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56187     } catch (std::out_of_range& e) {
56188       {
56189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56190       };
56191     } catch (std::exception& e) {
56192       {
56193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56194       };
56195     } catch (Dali::DaliException e) {
56196       {
56197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56198       };
56199     } catch (...) {
56200       {
56201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56202       };
56203     }
56204   }
56205
56206   jresult = (void *)result;
56207   return jresult;
56208 }
56209
56210
56211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56212   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56213
56214   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56215   {
56216     try {
56217       delete arg1;
56218     } catch (std::out_of_range& e) {
56219       {
56220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56221       };
56222     } catch (std::exception& e) {
56223       {
56224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56225       };
56226     } catch (Dali::DaliException e) {
56227       {
56228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56229       };
56230     } catch (...) {
56231       {
56232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56233       };
56234     }
56235   }
56236
56237 }
56238
56239
56240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56241   unsigned int jresult ;
56242   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56243   bool result;
56244
56245   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56246   {
56247     try {
56248       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56249     } catch (std::out_of_range& e) {
56250       {
56251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56252       };
56253     } catch (std::exception& e) {
56254       {
56255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56256       };
56257     } catch (Dali::DaliException e) {
56258       {
56259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56260       };
56261     } catch (...) {
56262       {
56263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56264       };
56265     }
56266   }
56267
56268   jresult = result;
56269   return jresult;
56270 }
56271
56272
56273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56274   unsigned long jresult ;
56275   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56276   std::size_t result;
56277
56278   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56279   {
56280     try {
56281       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56282     } catch (std::out_of_range& e) {
56283       {
56284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56285       };
56286     } catch (std::exception& e) {
56287       {
56288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56289       };
56290     } catch (Dali::DaliException e) {
56291       {
56292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56293       };
56294     } catch (...) {
56295       {
56296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56297       };
56298     }
56299   }
56300
56301   jresult = (unsigned long)result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56307   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56308   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56309
56310   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56311   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56312   {
56313     try {
56314       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56315     } catch (std::out_of_range& e) {
56316       {
56317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56318       };
56319     } catch (std::exception& e) {
56320       {
56321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56322       };
56323     } catch (Dali::DaliException e) {
56324       {
56325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56326       };
56327     } catch (...) {
56328       {
56329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56330       };
56331     }
56332   }
56333
56334 }
56335
56336
56337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56338   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56339   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56340
56341   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56342   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56343   {
56344     try {
56345       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56346     } catch (std::out_of_range& e) {
56347       {
56348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56349       };
56350     } catch (std::exception& e) {
56351       {
56352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56353       };
56354     } catch (Dali::DaliException e) {
56355       {
56356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56357       };
56358     } catch (...) {
56359       {
56360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56361       };
56362     }
56363   }
56364
56365 }
56366
56367
56368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56369   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56370   Dali::TouchData *arg2 = 0 ;
56371
56372   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56373   arg2 = (Dali::TouchData *)jarg2;
56374   if (!arg2) {
56375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56376     return ;
56377   }
56378   {
56379     try {
56380       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56381     } catch (std::out_of_range& e) {
56382       {
56383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56384       };
56385     } catch (std::exception& e) {
56386       {
56387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56388       };
56389     } catch (Dali::DaliException e) {
56390       {
56391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56392       };
56393     } catch (...) {
56394       {
56395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56396       };
56397     }
56398   }
56399
56400 }
56401
56402
56403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56404   void * jresult ;
56405   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56406
56407   {
56408     try {
56409       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56410     } catch (std::out_of_range& e) {
56411       {
56412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56413       };
56414     } catch (std::exception& e) {
56415       {
56416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56417       };
56418     } catch (Dali::DaliException e) {
56419       {
56420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56421       };
56422     } catch (...) {
56423       {
56424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56425       };
56426     }
56427   }
56428
56429   jresult = (void *)result;
56430   return jresult;
56431 }
56432
56433
56434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56435   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56436
56437   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56438   {
56439     try {
56440       delete arg1;
56441     } catch (std::out_of_range& e) {
56442       {
56443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56444       };
56445     } catch (std::exception& e) {
56446       {
56447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56448       };
56449     } catch (Dali::DaliException e) {
56450       {
56451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56452       };
56453     } catch (...) {
56454       {
56455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56456       };
56457     }
56458   }
56459
56460 }
56461
56462
56463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56464   unsigned int jresult ;
56465   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56466   bool result;
56467
56468   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56469   {
56470     try {
56471       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56472     } catch (std::out_of_range& e) {
56473       {
56474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56475       };
56476     } catch (std::exception& e) {
56477       {
56478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56479       };
56480     } catch (Dali::DaliException e) {
56481       {
56482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56483       };
56484     } catch (...) {
56485       {
56486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56487       };
56488     }
56489   }
56490
56491   jresult = result;
56492   return jresult;
56493 }
56494
56495
56496 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56497   unsigned long jresult ;
56498   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56499   std::size_t result;
56500
56501   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56502   {
56503     try {
56504       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56505     } catch (std::out_of_range& e) {
56506       {
56507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56508       };
56509     } catch (std::exception& e) {
56510       {
56511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56512       };
56513     } catch (Dali::DaliException e) {
56514       {
56515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56516       };
56517     } catch (...) {
56518       {
56519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56520       };
56521     }
56522   }
56523
56524   jresult = (unsigned long)result;
56525   return jresult;
56526 }
56527
56528
56529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56530   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56531   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56532
56533   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56534   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56535   {
56536     try {
56537       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56538     } catch (std::out_of_range& e) {
56539       {
56540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56541       };
56542     } catch (std::exception& e) {
56543       {
56544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56545       };
56546     } catch (Dali::DaliException e) {
56547       {
56548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56549       };
56550     } catch (...) {
56551       {
56552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56553       };
56554     }
56555   }
56556
56557 }
56558
56559
56560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56561   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56562   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56563
56564   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56565   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56566   {
56567     try {
56568       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56569     } catch (std::out_of_range& e) {
56570       {
56571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56572       };
56573     } catch (std::exception& e) {
56574       {
56575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56576       };
56577     } catch (Dali::DaliException e) {
56578       {
56579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56580       };
56581     } catch (...) {
56582       {
56583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56584       };
56585     }
56586   }
56587
56588 }
56589
56590
56591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56592   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56593   Dali::WheelEvent *arg2 = 0 ;
56594
56595   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56596   arg2 = (Dali::WheelEvent *)jarg2;
56597   if (!arg2) {
56598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56599     return ;
56600   }
56601   {
56602     try {
56603       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56604     } catch (std::out_of_range& e) {
56605       {
56606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56607       };
56608     } catch (std::exception& e) {
56609       {
56610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56611       };
56612     } catch (Dali::DaliException e) {
56613       {
56614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56615       };
56616     } catch (...) {
56617       {
56618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56619       };
56620     }
56621   }
56622
56623 }
56624
56625
56626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56627   void * jresult ;
56628   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56629
56630   {
56631     try {
56632       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56633     } catch (std::out_of_range& e) {
56634       {
56635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56636       };
56637     } catch (std::exception& e) {
56638       {
56639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (Dali::DaliException e) {
56642       {
56643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56644       };
56645     } catch (...) {
56646       {
56647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56648       };
56649     }
56650   }
56651
56652   jresult = (void *)result;
56653   return jresult;
56654 }
56655
56656
56657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56658   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56659
56660   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56661   {
56662     try {
56663       delete arg1;
56664     } catch (std::out_of_range& e) {
56665       {
56666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56667       };
56668     } catch (std::exception& e) {
56669       {
56670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56671       };
56672     } catch (Dali::DaliException e) {
56673       {
56674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56675       };
56676     } catch (...) {
56677       {
56678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56679       };
56680     }
56681   }
56682
56683 }
56684
56685
56686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56687   void * jresult ;
56688   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56689
56690   {
56691     try {
56692       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (Dali::DaliException e) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56704       };
56705     } catch (...) {
56706       {
56707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56708       };
56709     }
56710   }
56711
56712   jresult = (void *)result;
56713   return jresult;
56714 }
56715
56716
56717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56718   void * jresult ;
56719   Dali::Radian arg1 ;
56720   Dali::Radian arg2 ;
56721   Dali::Radian *argp1 ;
56722   Dali::Radian *argp2 ;
56723   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56724
56725   argp1 = (Dali::Radian *)jarg1;
56726   if (!argp1) {
56727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56728     return 0;
56729   }
56730   arg1 = *argp1;
56731   argp2 = (Dali::Radian *)jarg2;
56732   if (!argp2) {
56733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56734     return 0;
56735   }
56736   arg2 = *argp2;
56737   {
56738     try {
56739       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56755       };
56756     }
56757   }
56758
56759   jresult = (void *)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56765   void * jresult ;
56766   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56767   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56768
56769   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56770   if (!arg1) {
56771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56772     return 0;
56773   }
56774   {
56775     try {
56776       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56777     } catch (std::out_of_range& e) {
56778       {
56779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56780       };
56781     } catch (std::exception& e) {
56782       {
56783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (Dali::DaliException e) {
56786       {
56787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56788       };
56789     } catch (...) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56792       };
56793     }
56794   }
56795
56796   jresult = (void *)result;
56797   return jresult;
56798 }
56799
56800
56801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56802   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56803   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56804
56805   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56806   arg2 = (Dali::Radian *)jarg2;
56807   if (arg1) (arg1)->first = *arg2;
56808 }
56809
56810
56811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56812   void * jresult ;
56813   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56814   Dali::Radian *result = 0 ;
56815
56816   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56817   result = (Dali::Radian *)& ((arg1)->first);
56818   jresult = (void *)result;
56819   return jresult;
56820 }
56821
56822
56823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56824   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56825   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56826
56827   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56828   arg2 = (Dali::Radian *)jarg2;
56829   if (arg1) (arg1)->second = *arg2;
56830 }
56831
56832
56833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
56834   void * jresult ;
56835   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56836   Dali::Radian *result = 0 ;
56837
56838   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56839   result = (Dali::Radian *)& ((arg1)->second);
56840   jresult = (void *)result;
56841   return jresult;
56842 }
56843
56844
56845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
56846   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56847
56848   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56849   {
56850     try {
56851       delete arg1;
56852     } catch (std::out_of_range& e) {
56853       {
56854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56855       };
56856     } catch (std::exception& e) {
56857       {
56858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56859       };
56860     } catch (Dali::DaliException e) {
56861       {
56862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56863       };
56864     } catch (...) {
56865       {
56866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56867       };
56868     }
56869   }
56870
56871 }
56872
56873
56874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
56875   unsigned int jresult ;
56876   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56877   bool result;
56878
56879   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56880   {
56881     try {
56882       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);
56883     } catch (std::out_of_range& e) {
56884       {
56885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56886       };
56887     } catch (std::exception& e) {
56888       {
56889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56890       };
56891     } catch (Dali::DaliException e) {
56892       {
56893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56894       };
56895     } catch (...) {
56896       {
56897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56898       };
56899     }
56900   }
56901
56902   jresult = result;
56903   return jresult;
56904 }
56905
56906
56907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56908   unsigned long jresult ;
56909   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56910   std::size_t result;
56911
56912   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56913   {
56914     try {
56915       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);
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 = (unsigned long)result;
56936   return jresult;
56937 }
56938
56939
56940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56941   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56942   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56943
56944   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56945   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56946   {
56947     try {
56948       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56949     } catch (std::out_of_range& e) {
56950       {
56951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56952       };
56953     } catch (std::exception& e) {
56954       {
56955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56956       };
56957     } catch (Dali::DaliException e) {
56958       {
56959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56964       };
56965     }
56966   }
56967
56968 }
56969
56970
56971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
56972   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56973   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56974
56975   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56976   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56977   {
56978     try {
56979       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56980     } catch (std::out_of_range& e) {
56981       {
56982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56983       };
56984     } catch (std::exception& e) {
56985       {
56986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56987       };
56988     } catch (Dali::DaliException e) {
56989       {
56990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56991       };
56992     } catch (...) {
56993       {
56994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56995       };
56996     }
56997   }
56998
56999 }
57000
57001
57002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57003   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57004   Dali::Actor arg2 ;
57005   Dali::PanGesture *arg3 = 0 ;
57006   Dali::Actor *argp2 ;
57007
57008   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57009   argp2 = (Dali::Actor *)jarg2;
57010   if (!argp2) {
57011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57012     return ;
57013   }
57014   arg2 = *argp2;
57015   arg3 = (Dali::PanGesture *)jarg3;
57016   if (!arg3) {
57017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57018     return ;
57019   }
57020   {
57021     try {
57022       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57023     } catch (std::out_of_range& e) {
57024       {
57025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57026       };
57027     } catch (std::exception& e) {
57028       {
57029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (Dali::DaliException e) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57038       };
57039     }
57040   }
57041
57042 }
57043
57044
57045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57046   void * jresult ;
57047   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57048
57049   {
57050     try {
57051       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57052     } catch (std::out_of_range& e) {
57053       {
57054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57055       };
57056     } catch (std::exception& e) {
57057       {
57058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57059       };
57060     } catch (Dali::DaliException e) {
57061       {
57062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57063       };
57064     } catch (...) {
57065       {
57066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57067       };
57068     }
57069   }
57070
57071   jresult = (void *)result;
57072   return jresult;
57073 }
57074
57075
57076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57077   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57078
57079   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57080   {
57081     try {
57082       delete arg1;
57083     } catch (std::out_of_range& e) {
57084       {
57085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57086       };
57087     } catch (std::exception& e) {
57088       {
57089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57090       };
57091     } catch (Dali::DaliException e) {
57092       {
57093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57094       };
57095     } catch (...) {
57096       {
57097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57098       };
57099     }
57100   }
57101
57102 }
57103
57104
57105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57106   unsigned int jresult ;
57107   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57108   bool result;
57109
57110   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57111   {
57112     try {
57113       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);
57114     } catch (std::out_of_range& e) {
57115       {
57116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57117       };
57118     } catch (std::exception& e) {
57119       {
57120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57121       };
57122     } catch (Dali::DaliException e) {
57123       {
57124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57125       };
57126     } catch (...) {
57127       {
57128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57129       };
57130     }
57131   }
57132
57133   jresult = result;
57134   return jresult;
57135 }
57136
57137
57138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57139   unsigned long jresult ;
57140   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57141   std::size_t result;
57142
57143   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57144   {
57145     try {
57146       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);
57147     } catch (std::out_of_range& e) {
57148       {
57149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (std::exception& e) {
57152       {
57153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57154       };
57155     } catch (Dali::DaliException e) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57158       };
57159     } catch (...) {
57160       {
57161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57162       };
57163     }
57164   }
57165
57166   jresult = (unsigned long)result;
57167   return jresult;
57168 }
57169
57170
57171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57172   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57173   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57174
57175   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57176   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57177   {
57178     try {
57179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57180     } catch (std::out_of_range& e) {
57181       {
57182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57183       };
57184     } catch (std::exception& e) {
57185       {
57186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57187       };
57188     } catch (Dali::DaliException e) {
57189       {
57190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57191       };
57192     } catch (...) {
57193       {
57194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57195       };
57196     }
57197   }
57198
57199 }
57200
57201
57202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57203   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57204   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57205
57206   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57207   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57208   {
57209     try {
57210       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57211     } catch (std::out_of_range& e) {
57212       {
57213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57214       };
57215     } catch (std::exception& e) {
57216       {
57217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57218       };
57219     } catch (Dali::DaliException e) {
57220       {
57221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57222       };
57223     } catch (...) {
57224       {
57225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57226       };
57227     }
57228   }
57229
57230 }
57231
57232
57233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57234   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57235   Dali::Actor arg2 ;
57236   Dali::PinchGesture *arg3 = 0 ;
57237   Dali::Actor *argp2 ;
57238
57239   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57240   argp2 = (Dali::Actor *)jarg2;
57241   if (!argp2) {
57242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57243     return ;
57244   }
57245   arg2 = *argp2;
57246   arg3 = (Dali::PinchGesture *)jarg3;
57247   if (!arg3) {
57248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57249     return ;
57250   }
57251   {
57252     try {
57253       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57254     } catch (std::out_of_range& e) {
57255       {
57256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57257       };
57258     } catch (std::exception& e) {
57259       {
57260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (Dali::DaliException e) {
57263       {
57264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57265       };
57266     } catch (...) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57269       };
57270     }
57271   }
57272
57273 }
57274
57275
57276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57277   void * jresult ;
57278   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57279
57280   {
57281     try {
57282       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57283     } catch (std::out_of_range& e) {
57284       {
57285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57286       };
57287     } catch (std::exception& e) {
57288       {
57289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57290       };
57291     } catch (Dali::DaliException e) {
57292       {
57293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57298       };
57299     }
57300   }
57301
57302   jresult = (void *)result;
57303   return jresult;
57304 }
57305
57306
57307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57308   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57309
57310   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57311   {
57312     try {
57313       delete arg1;
57314     } catch (std::out_of_range& e) {
57315       {
57316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57317       };
57318     } catch (std::exception& e) {
57319       {
57320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57321       };
57322     } catch (Dali::DaliException e) {
57323       {
57324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57325       };
57326     } catch (...) {
57327       {
57328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57329       };
57330     }
57331   }
57332
57333 }
57334
57335
57336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57337   unsigned int jresult ;
57338   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57339   bool result;
57340
57341   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57342   {
57343     try {
57344       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);
57345     } catch (std::out_of_range& e) {
57346       {
57347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57348       };
57349     } catch (std::exception& e) {
57350       {
57351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57352       };
57353     } catch (Dali::DaliException e) {
57354       {
57355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57356       };
57357     } catch (...) {
57358       {
57359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57360       };
57361     }
57362   }
57363
57364   jresult = result;
57365   return jresult;
57366 }
57367
57368
57369 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57370   unsigned long jresult ;
57371   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57372   std::size_t result;
57373
57374   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57375   {
57376     try {
57377       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);
57378     } catch (std::out_of_range& e) {
57379       {
57380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57381       };
57382     } catch (std::exception& e) {
57383       {
57384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (Dali::DaliException e) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57389       };
57390     } catch (...) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57393       };
57394     }
57395   }
57396
57397   jresult = (unsigned long)result;
57398   return jresult;
57399 }
57400
57401
57402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57403   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57404   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57405
57406   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57407   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57408   {
57409     try {
57410       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57411     } catch (std::out_of_range& e) {
57412       {
57413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57414       };
57415     } catch (std::exception& e) {
57416       {
57417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57418       };
57419     } catch (Dali::DaliException e) {
57420       {
57421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57422       };
57423     } catch (...) {
57424       {
57425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57426       };
57427     }
57428   }
57429
57430 }
57431
57432
57433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57434   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57435   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57436
57437   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57438   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57439   {
57440     try {
57441       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57442     } catch (std::out_of_range& e) {
57443       {
57444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57445       };
57446     } catch (std::exception& e) {
57447       {
57448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57449       };
57450     } catch (Dali::DaliException e) {
57451       {
57452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57453       };
57454     } catch (...) {
57455       {
57456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57457       };
57458     }
57459   }
57460
57461 }
57462
57463
57464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57465   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57466   Dali::Actor arg2 ;
57467   Dali::TapGesture *arg3 = 0 ;
57468   Dali::Actor *argp2 ;
57469
57470   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57471   argp2 = (Dali::Actor *)jarg2;
57472   if (!argp2) {
57473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57474     return ;
57475   }
57476   arg2 = *argp2;
57477   arg3 = (Dali::TapGesture *)jarg3;
57478   if (!arg3) {
57479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57480     return ;
57481   }
57482   {
57483     try {
57484       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57485     } catch (std::out_of_range& e) {
57486       {
57487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57488       };
57489     } catch (std::exception& e) {
57490       {
57491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (Dali::DaliException e) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57500       };
57501     }
57502   }
57503
57504 }
57505
57506
57507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57508   void * jresult ;
57509   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57510
57511   {
57512     try {
57513       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57514     } catch (std::out_of_range& e) {
57515       {
57516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57517       };
57518     } catch (std::exception& e) {
57519       {
57520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57521       };
57522     } catch (Dali::DaliException e) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57525       };
57526     } catch (...) {
57527       {
57528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57529       };
57530     }
57531   }
57532
57533   jresult = (void *)result;
57534   return jresult;
57535 }
57536
57537
57538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57539   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57540
57541   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57542   {
57543     try {
57544       delete arg1;
57545     } catch (std::out_of_range& e) {
57546       {
57547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57548       };
57549     } catch (std::exception& e) {
57550       {
57551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57552       };
57553     } catch (Dali::DaliException e) {
57554       {
57555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57556       };
57557     } catch (...) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57560       };
57561     }
57562   }
57563
57564 }
57565
57566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57567   unsigned int jresult ;
57568   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57569   bool result;
57570
57571   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57572   {
57573     try {
57574       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57575     } catch (std::out_of_range& e) {
57576       {
57577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57578       };
57579     } catch (std::exception& e) {
57580       {
57581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57582       };
57583     } catch (Dali::DaliException e) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57586       };
57587     } catch (...) {
57588       {
57589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57590       };
57591     }
57592   }
57593
57594   jresult = result;
57595   return jresult;
57596 }
57597
57598
57599 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57600   unsigned long jresult ;
57601   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57602   std::size_t result;
57603
57604   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57605   {
57606     try {
57607       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57608     } catch (std::out_of_range& e) {
57609       {
57610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57611       };
57612     } catch (std::exception& e) {
57613       {
57614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (Dali::DaliException e) {
57617       {
57618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57619       };
57620     } catch (...) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57623       };
57624     }
57625   }
57626
57627   jresult = (unsigned long)result;
57628   return jresult;
57629 }
57630
57631
57632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57633   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57634   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57635
57636   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57637   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57638   {
57639     try {
57640       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57641     } catch (std::out_of_range& e) {
57642       {
57643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57644       };
57645     } catch (std::exception& e) {
57646       {
57647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57648       };
57649     } catch (Dali::DaliException e) {
57650       {
57651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57652       };
57653     } catch (...) {
57654       {
57655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57656       };
57657     }
57658   }
57659
57660 }
57661
57662
57663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57664   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57665   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57666
57667   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57668   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57669   {
57670     try {
57671       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57672     } catch (std::out_of_range& e) {
57673       {
57674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57675       };
57676     } catch (std::exception& e) {
57677       {
57678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57679       };
57680     } catch (Dali::DaliException e) {
57681       {
57682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57687       };
57688     }
57689   }
57690
57691 }
57692
57693
57694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57695   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57696   Dali::ResourceImage arg2 ;
57697   Dali::ResourceImage *argp2 ;
57698
57699   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57700   argp2 = (Dali::ResourceImage *)jarg2;
57701   if (!argp2) {
57702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57703     return ;
57704   }
57705   arg2 = *argp2;
57706   {
57707     try {
57708       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57709     } catch (std::out_of_range& e) {
57710       {
57711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57712       };
57713     } catch (std::exception& e) {
57714       {
57715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57716       };
57717     } catch (Dali::DaliException e) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57720       };
57721     } catch (...) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57724       };
57725     }
57726   }
57727
57728 }
57729
57730
57731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57732   void * jresult ;
57733   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57734
57735   {
57736     try {
57737       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57738     } catch (std::out_of_range& e) {
57739       {
57740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57741       };
57742     } catch (std::exception& e) {
57743       {
57744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57745       };
57746     } catch (Dali::DaliException e) {
57747       {
57748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57749       };
57750     } catch (...) {
57751       {
57752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57753       };
57754     }
57755   }
57756
57757   jresult = (void *)result;
57758   return jresult;
57759 }
57760
57761
57762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57763   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57764
57765   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57766   {
57767     try {
57768       delete arg1;
57769     } catch (std::out_of_range& e) {
57770       {
57771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57772       };
57773     } catch (std::exception& e) {
57774       {
57775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57776       };
57777     } catch (Dali::DaliException e) {
57778       {
57779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57780       };
57781     } catch (...) {
57782       {
57783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57784       };
57785     }
57786   }
57787
57788 }
57789
57790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57791   unsigned int jresult ;
57792   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57793   bool result = false;
57794
57795   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57796   {
57797     try {
57798       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);
57799     } catch (std::out_of_range& e) {
57800       {
57801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57802       };
57803     } catch (std::exception& e) {
57804       {
57805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57806       };
57807     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57808   }
57809   jresult = result;
57810   return jresult;
57811 }
57812
57813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57814   unsigned long jresult ;
57815   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57816   std::size_t result = 0;
57817
57818   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57819   {
57820     try {
57821       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);
57822     } catch (std::out_of_range& e) {
57823       {
57824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57825       };
57826     } catch (std::exception& e) {
57827       {
57828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57829       };
57830     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57831   }
57832   jresult = (unsigned long)result;
57833   return jresult;
57834 }
57835
57836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
57837   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57838   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57839
57840   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57841   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57842   {
57843     try {
57844       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
57845     } catch (std::out_of_range& e) {
57846       {
57847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57848       };
57849     } catch (std::exception& e) {
57850       {
57851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57852       };
57853     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57854   }
57855 }
57856
57857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
57858   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57859   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57860
57861   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57862   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57863   {
57864     try {
57865       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
57866     } catch (std::out_of_range& e) {
57867       {
57868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57869       };
57870     } catch (std::exception& e) {
57871       {
57872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57873       };
57874     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57875   }
57876 }
57877
57878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
57879   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57880   Dali::Actor arg2 ;
57881   //bool arg3 ;
57882   Dali::LayoutDirection::Type arg4 ;
57883   Dali::Actor *argp2 ;
57884
57885   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57886   argp2 = (Dali::Actor *)jarg2;
57887   if (!argp2) {
57888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57889     return ;
57890   }
57891   arg2 = *argp2;
57892   //arg3 = jarg3 ? true : false;
57893   arg4 = (Dali::LayoutDirection::Type)jarg4;
57894   {
57895     try {
57896       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
57897     } catch (std::out_of_range& e) {
57898       {
57899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57900       };
57901     } catch (std::exception& e) {
57902       {
57903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57904       };
57905     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57906   }
57907 }
57908
57909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
57910   void * jresult ;
57911   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
57912
57913   {
57914     try {
57915       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
57916     } catch (std::out_of_range& e) {
57917       {
57918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57919       };
57920     } catch (std::exception& e) {
57921       {
57922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57923       };
57924     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57925   }
57926   jresult = (void *)result;
57927   return jresult;
57928 }
57929
57930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
57931   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57932
57933   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57934   {
57935     try {
57936       delete arg1;
57937     } catch (std::out_of_range& e) {
57938       {
57939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57940       };
57941     } catch (std::exception& e) {
57942       {
57943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57944       };
57945     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57946   }
57947 }
57948
57949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
57950   unsigned int jresult ;
57951   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57952   bool result;
57953
57954   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57955   {
57956     try {
57957       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);
57958     } catch (std::out_of_range& e) {
57959       {
57960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57961       };
57962     } catch (std::exception& e) {
57963       {
57964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (Dali::DaliException e) {
57967       {
57968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976
57977   jresult = result;
57978   return jresult;
57979 }
57980
57981
57982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
57983   unsigned long jresult ;
57984   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57985   std::size_t result;
57986
57987   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57988   {
57989     try {
57990       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);
57991     } catch (std::out_of_range& e) {
57992       {
57993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57994       };
57995     } catch (std::exception& e) {
57996       {
57997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57998       };
57999     } catch (Dali::DaliException e) {
58000       {
58001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58002       };
58003     } catch (...) {
58004       {
58005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58006       };
58007     }
58008   }
58009
58010   jresult = (unsigned long)result;
58011   return jresult;
58012 }
58013
58014
58015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58016   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58017   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58018
58019   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58020   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58021   {
58022     try {
58023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58024     } catch (std::out_of_range& e) {
58025       {
58026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58027       };
58028     } catch (std::exception& e) {
58029       {
58030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58031       };
58032     } catch (Dali::DaliException e) {
58033       {
58034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58035       };
58036     } catch (...) {
58037       {
58038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58039       };
58040     }
58041   }
58042
58043 }
58044
58045
58046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58047   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58048   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58049
58050   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58051   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58052   {
58053     try {
58054       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58055     } catch (std::out_of_range& e) {
58056       {
58057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58058       };
58059     } catch (std::exception& e) {
58060       {
58061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58062       };
58063     } catch (Dali::DaliException e) {
58064       {
58065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58066       };
58067     } catch (...) {
58068       {
58069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58070       };
58071     }
58072   }
58073
58074 }
58075
58076
58077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58078   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58079   Dali::Actor arg2 ;
58080   bool arg3 ;
58081   Dali::DevelActor::VisibilityChange::Type arg4 ;
58082   Dali::Actor *argp2 ;
58083
58084   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58085   argp2 = (Dali::Actor *)jarg2;
58086   if (!argp2) {
58087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58088     return ;
58089   }
58090   arg2 = *argp2;
58091   arg3 = jarg3 ? true : false;
58092   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58093   {
58094     try {
58095       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58096     } catch (std::out_of_range& e) {
58097       {
58098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58099       };
58100     } catch (std::exception& e) {
58101       {
58102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58103       };
58104     } catch (Dali::DaliException e) {
58105       {
58106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58107       };
58108     } catch (...) {
58109       {
58110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58111       };
58112     }
58113   }
58114
58115 }
58116
58117
58118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58119   void * jresult ;
58120   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58121
58122   {
58123     try {
58124       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58125     } catch (std::out_of_range& e) {
58126       {
58127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58128       };
58129     } catch (std::exception& e) {
58130       {
58131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (Dali::DaliException e) {
58134       {
58135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58136       };
58137     } catch (...) {
58138       {
58139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58140       };
58141     }
58142   }
58143
58144   jresult = (void *)result;
58145   return jresult;
58146 }
58147
58148
58149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58150   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58151
58152   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58153   {
58154     try {
58155       delete arg1;
58156     } catch (std::out_of_range& e) {
58157       {
58158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58159       };
58160     } catch (std::exception& e) {
58161       {
58162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58163       };
58164     } catch (Dali::DaliException e) {
58165       {
58166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58167       };
58168     } catch (...) {
58169       {
58170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58171       };
58172     }
58173   }
58174
58175 }
58176
58177
58178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58179   void * jresult ;
58180   Dali::Timer *result = 0 ;
58181
58182   {
58183     try {
58184       result = (Dali::Timer *)new Dali::Timer();
58185     } catch (std::out_of_range& e) {
58186       {
58187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58188       };
58189     } catch (std::exception& e) {
58190       {
58191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58192       };
58193     } catch (Dali::DaliException e) {
58194       {
58195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58196       };
58197     } catch (...) {
58198       {
58199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58200       };
58201     }
58202   }
58203
58204   jresult = (void *)result;
58205   return jresult;
58206 }
58207
58208
58209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58210   void * jresult ;
58211   unsigned int arg1 ;
58212   Dali::Timer result;
58213
58214   arg1 = (unsigned int)jarg1;
58215   {
58216     try {
58217       result = Dali::Timer::New(arg1);
58218     } catch (std::out_of_range& e) {
58219       {
58220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58221       };
58222     } catch (std::exception& e) {
58223       {
58224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (Dali::DaliException e) {
58227       {
58228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236
58237   jresult = new Dali::Timer((const Dali::Timer &)result);
58238   return jresult;
58239 }
58240
58241
58242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58243   void * jresult ;
58244   Dali::Timer *arg1 = 0 ;
58245   Dali::Timer *result = 0 ;
58246
58247   arg1 = (Dali::Timer *)jarg1;
58248   if (!arg1) {
58249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58250     return 0;
58251   }
58252   {
58253     try {
58254       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58255     } catch (std::out_of_range& e) {
58256       {
58257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (std::exception& e) {
58260       {
58261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58262       };
58263     } catch (Dali::DaliException e) {
58264       {
58265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58266       };
58267     } catch (...) {
58268       {
58269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58270       };
58271     }
58272   }
58273
58274   jresult = (void *)result;
58275   return jresult;
58276 }
58277
58278
58279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58280   void * jresult ;
58281   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58282   Dali::Timer *arg2 = 0 ;
58283   Dali::Timer *result = 0 ;
58284
58285   arg1 = (Dali::Timer *)jarg1;
58286   arg2 = (Dali::Timer *)jarg2;
58287   if (!arg2) {
58288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58289     return 0;
58290   }
58291   {
58292     try {
58293       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58294     } catch (std::out_of_range& e) {
58295       {
58296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58297       };
58298     } catch (std::exception& e) {
58299       {
58300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58301       };
58302     } catch (Dali::DaliException e) {
58303       {
58304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58305       };
58306     } catch (...) {
58307       {
58308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58309       };
58310     }
58311   }
58312
58313   jresult = (void *)result;
58314   return jresult;
58315 }
58316
58317
58318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58319   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58320
58321   arg1 = (Dali::Timer *)jarg1;
58322   {
58323     try {
58324       delete arg1;
58325     } catch (std::out_of_range& e) {
58326       {
58327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58328       };
58329     } catch (std::exception& e) {
58330       {
58331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58332       };
58333     } catch (Dali::DaliException e) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58340       };
58341     }
58342   }
58343
58344 }
58345
58346
58347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58348   void * jresult ;
58349   Dali::BaseHandle arg1 ;
58350   Dali::BaseHandle *argp1 ;
58351   Dali::Timer result;
58352
58353   argp1 = (Dali::BaseHandle *)jarg1;
58354   if (!argp1) {
58355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58356     return 0;
58357   }
58358   arg1 = *argp1;
58359   {
58360     try {
58361       result = Dali::Timer::DownCast(arg1);
58362     } catch (std::out_of_range& e) {
58363       {
58364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58365       };
58366     } catch (std::exception& e) {
58367       {
58368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58369       };
58370     } catch (Dali::DaliException e) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58373       };
58374     } catch (...) {
58375       {
58376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58377       };
58378     }
58379   }
58380
58381   jresult = new Dali::Timer((const Dali::Timer &)result);
58382   return jresult;
58383 }
58384
58385
58386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58387   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58388
58389   arg1 = (Dali::Timer *)jarg1;
58390   {
58391     try {
58392       (arg1)->Start();
58393     } catch (std::out_of_range& e) {
58394       {
58395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58396       };
58397     } catch (std::exception& e) {
58398       {
58399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58400       };
58401     } catch (Dali::DaliException e) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58404       };
58405     } catch (...) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58408       };
58409     }
58410   }
58411
58412 }
58413
58414
58415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58416   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58417
58418   arg1 = (Dali::Timer *)jarg1;
58419   {
58420     try {
58421       (arg1)->Stop();
58422     } catch (std::out_of_range& e) {
58423       {
58424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58425       };
58426     } catch (std::exception& e) {
58427       {
58428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58429       };
58430     } catch (Dali::DaliException e) {
58431       {
58432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58433       };
58434     } catch (...) {
58435       {
58436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58437       };
58438     }
58439   }
58440
58441 }
58442
58443
58444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58445   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58446   unsigned int arg2 ;
58447
58448   arg1 = (Dali::Timer *)jarg1;
58449   arg2 = (unsigned int)jarg2;
58450   {
58451     try {
58452       (arg1)->SetInterval(arg2);
58453     } catch (std::out_of_range& e) {
58454       {
58455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58456       };
58457     } catch (std::exception& e) {
58458       {
58459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58460       };
58461     } catch (Dali::DaliException e) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58464       };
58465     } catch (...) {
58466       {
58467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58468       };
58469     }
58470   }
58471
58472 }
58473
58474
58475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58476   unsigned int jresult ;
58477   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58478   unsigned int result;
58479
58480   arg1 = (Dali::Timer *)jarg1;
58481   {
58482     try {
58483       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58484     } catch (std::out_of_range& e) {
58485       {
58486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58487       };
58488     } catch (std::exception& e) {
58489       {
58490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58491       };
58492     } catch (Dali::DaliException e) {
58493       {
58494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58495       };
58496     } catch (...) {
58497       {
58498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58499       };
58500     }
58501   }
58502
58503   jresult = result;
58504   return jresult;
58505 }
58506
58507
58508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58509   unsigned int jresult ;
58510   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58511   bool result;
58512
58513   arg1 = (Dali::Timer *)jarg1;
58514   {
58515     try {
58516       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58517     } catch (std::out_of_range& e) {
58518       {
58519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58520       };
58521     } catch (std::exception& e) {
58522       {
58523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58524       };
58525     } catch (Dali::DaliException e) {
58526       {
58527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58528       };
58529     } catch (...) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58532       };
58533     }
58534   }
58535
58536   jresult = result;
58537   return jresult;
58538 }
58539
58540
58541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58542   void * jresult ;
58543   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58544   Dali::Timer::TimerSignalType *result = 0 ;
58545
58546   arg1 = (Dali::Timer *)jarg1;
58547   {
58548     try {
58549       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58550     } catch (std::out_of_range& e) {
58551       {
58552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58553       };
58554     } catch (std::exception& e) {
58555       {
58556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (Dali::DaliException e) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58561       };
58562     } catch (...) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58565       };
58566     }
58567   }
58568
58569   jresult = (void *)result;
58570   return jresult;
58571 }
58572
58573
58574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58575   void * jresult ;
58576   Dali::DragAndDropDetector *result = 0 ;
58577
58578   {
58579     try {
58580       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58581     } catch (std::out_of_range& e) {
58582       {
58583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58584       };
58585     } catch (std::exception& e) {
58586       {
58587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (Dali::DaliException e) {
58590       {
58591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58592       };
58593     } catch (...) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58596       };
58597     }
58598   }
58599
58600   jresult = (void *)result;
58601   return jresult;
58602 }
58603
58604
58605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58606   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58607
58608   arg1 = (Dali::DragAndDropDetector *)jarg1;
58609   {
58610     try {
58611       delete arg1;
58612     } catch (std::out_of_range& e) {
58613       {
58614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58615       };
58616     } catch (std::exception& e) {
58617       {
58618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58619       };
58620     } catch (Dali::DaliException e) {
58621       {
58622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58623       };
58624     } catch (...) {
58625       {
58626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58627       };
58628     }
58629   }
58630
58631 }
58632
58633
58634 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58635   char * jresult ;
58636   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58637   std::string *result = 0 ;
58638
58639   arg1 = (Dali::DragAndDropDetector *)jarg1;
58640   {
58641     try {
58642       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58643     } catch (std::out_of_range& e) {
58644       {
58645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58646       };
58647     } catch (std::exception& e) {
58648       {
58649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58650       };
58651     } catch (Dali::DaliException e) {
58652       {
58653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58654       };
58655     } catch (...) {
58656       {
58657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58658       };
58659     }
58660   }
58661
58662   jresult = SWIG_csharp_string_callback(result->c_str());
58663   return jresult;
58664 }
58665
58666
58667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58668   void * jresult ;
58669   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58670   Dali::Vector2 result;
58671
58672   arg1 = (Dali::DragAndDropDetector *)jarg1;
58673   {
58674     try {
58675       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58676     } catch (std::out_of_range& e) {
58677       {
58678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58679       };
58680     } catch (std::exception& e) {
58681       {
58682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58683       };
58684     } catch (Dali::DaliException e) {
58685       {
58686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58687       };
58688     } catch (...) {
58689       {
58690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58691       };
58692     }
58693   }
58694
58695   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58696   return jresult;
58697 }
58698
58699
58700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58701   void * jresult ;
58702   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58703   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58704
58705   arg1 = (Dali::DragAndDropDetector *)jarg1;
58706   {
58707     try {
58708       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58709     } catch (std::out_of_range& e) {
58710       {
58711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58712       };
58713     } catch (std::exception& e) {
58714       {
58715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58716       };
58717     } catch (Dali::DaliException e) {
58718       {
58719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58720       };
58721     } catch (...) {
58722       {
58723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58724       };
58725     }
58726   }
58727
58728   jresult = (void *)result;
58729   return jresult;
58730 }
58731
58732
58733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58734   void * jresult ;
58735   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58736   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58737
58738   arg1 = (Dali::DragAndDropDetector *)jarg1;
58739   {
58740     try {
58741       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58742     } catch (std::out_of_range& e) {
58743       {
58744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58745       };
58746     } catch (std::exception& e) {
58747       {
58748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58749       };
58750     } catch (Dali::DaliException e) {
58751       {
58752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58753       };
58754     } catch (...) {
58755       {
58756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58757       };
58758     }
58759   }
58760
58761   jresult = (void *)result;
58762   return jresult;
58763 }
58764
58765
58766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58767   void * jresult ;
58768   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58769   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58770
58771   arg1 = (Dali::DragAndDropDetector *)jarg1;
58772   {
58773     try {
58774       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58775     } catch (std::out_of_range& e) {
58776       {
58777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58778       };
58779     } catch (std::exception& e) {
58780       {
58781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58782       };
58783     } catch (Dali::DaliException e) {
58784       {
58785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58786       };
58787     } catch (...) {
58788       {
58789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58790       };
58791     }
58792   }
58793
58794   jresult = (void *)result;
58795   return jresult;
58796 }
58797
58798
58799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58800   void * jresult ;
58801   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58802   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58803
58804   arg1 = (Dali::DragAndDropDetector *)jarg1;
58805   {
58806     try {
58807       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58808     } catch (std::out_of_range& e) {
58809       {
58810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58811       };
58812     } catch (std::exception& e) {
58813       {
58814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58815       };
58816     } catch (Dali::DaliException e) {
58817       {
58818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58819       };
58820     } catch (...) {
58821       {
58822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58823       };
58824     }
58825   }
58826
58827   jresult = (void *)result;
58828   return jresult;
58829 }
58830
58831
58832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
58833   void * jresult ;
58834   Dali::ApplicationExtensions *result = 0 ;
58835
58836   {
58837     try {
58838       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
58839     } catch (std::out_of_range& e) {
58840       {
58841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58842       };
58843     } catch (std::exception& e) {
58844       {
58845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58846       };
58847     } catch (Dali::DaliException e) {
58848       {
58849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58850       };
58851     } catch (...) {
58852       {
58853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58854       };
58855     }
58856   }
58857
58858   jresult = (void *)result;
58859   return jresult;
58860 }
58861
58862
58863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
58864   void * jresult ;
58865   Dali::Application *arg1 = (Dali::Application *) 0 ;
58866   Dali::ApplicationExtensions *result = 0 ;
58867
58868   arg1 = (Dali::Application *)jarg1;
58869   {
58870     try {
58871       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
58872     } catch (std::out_of_range& e) {
58873       {
58874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58875       };
58876     } catch (std::exception& e) {
58877       {
58878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58879       };
58880     } catch (Dali::DaliException e) {
58881       {
58882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58883       };
58884     } catch (...) {
58885       {
58886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58887       };
58888     }
58889   }
58890
58891   jresult = (void *)result;
58892   return jresult;
58893 }
58894
58895
58896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
58897   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58898
58899   arg1 = (Dali::ApplicationExtensions *)jarg1;
58900   {
58901     try {
58902       delete arg1;
58903     } catch (std::out_of_range& e) {
58904       {
58905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58906       };
58907     } catch (std::exception& e) {
58908       {
58909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58910       };
58911     } catch (Dali::DaliException e) {
58912       {
58913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58914       };
58915     } catch (...) {
58916       {
58917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58918       };
58919     }
58920   }
58921
58922 }
58923
58924
58925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
58926   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58927
58928   arg1 = (Dali::ApplicationExtensions *)jarg1;
58929   {
58930     try {
58931       (arg1)->Init();
58932     } catch (std::out_of_range& e) {
58933       {
58934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58935       };
58936     } catch (std::exception& e) {
58937       {
58938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58939       };
58940     } catch (Dali::DaliException e) {
58941       {
58942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58943       };
58944     } catch (...) {
58945       {
58946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58947       };
58948     }
58949   }
58950
58951 }
58952
58953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
58954   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58955
58956   arg1 = (Dali::ApplicationExtensions *)jarg1;
58957   {
58958     try {
58959       (arg1)->Start();
58960     } catch (std::out_of_range& e) {
58961       {
58962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58963       };
58964     } catch (std::exception& e) {
58965       {
58966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58967       };
58968     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
58969   }
58970 }
58971
58972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
58973   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
58974
58975   arg1 = (Dali::ApplicationExtensions *)jarg1;
58976   {
58977     try {
58978       (arg1)->Terminate();
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58986       };
58987     } catch (Dali::DaliException e) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58990       };
58991     } catch (...) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58994       };
58995     }
58996   }
58997
58998 }
58999
59000
59001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59002   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59003
59004   arg1 = (Dali::ApplicationExtensions *)jarg1;
59005   {
59006     try {
59007       (arg1)->Pause();
59008     } catch (std::out_of_range& e) {
59009       {
59010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59011       };
59012     } catch (std::exception& e) {
59013       {
59014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59015       };
59016     } catch (Dali::DaliException e) {
59017       {
59018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59019       };
59020     } catch (...) {
59021       {
59022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59023       };
59024     }
59025   }
59026
59027 }
59028
59029
59030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59031   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59032
59033   arg1 = (Dali::ApplicationExtensions *)jarg1;
59034   {
59035     try {
59036       (arg1)->Resume();
59037     } catch (std::out_of_range& e) {
59038       {
59039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59040       };
59041     } catch (std::exception& e) {
59042       {
59043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59044       };
59045     } catch (Dali::DaliException e) {
59046       {
59047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59048       };
59049     } catch (...) {
59050       {
59051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59052       };
59053     }
59054   }
59055
59056 }
59057
59058
59059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59060   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59061
59062   arg1 = (Dali::ApplicationExtensions *)jarg1;
59063   {
59064     try {
59065       (arg1)->LanguageChange();
59066     } catch (std::out_of_range& e) {
59067       {
59068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59069       };
59070     } catch (std::exception& e) {
59071       {
59072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59073       };
59074     } catch (Dali::DaliException e) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59077       };
59078     } catch (...) {
59079       {
59080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59081       };
59082     }
59083   }
59084
59085 }
59086
59087
59088
59089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59090   unsigned int jresult ;
59091   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59092   bool result;
59093
59094   arg1 = (Dali::Signal< bool () > *)jarg1;
59095   {
59096     try {
59097       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59098     } catch (std::out_of_range& e) {
59099       {
59100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59101       };
59102     } catch (std::exception& e) {
59103       {
59104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59105       };
59106     } catch (Dali::DaliException e) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59109       };
59110     } catch (...) {
59111       {
59112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59113       };
59114     }
59115   }
59116
59117   jresult = result;
59118   return jresult;
59119 }
59120
59121
59122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59123   unsigned long jresult ;
59124   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59125   std::size_t result;
59126
59127   arg1 = (Dali::Signal< bool () > *)jarg1;
59128   {
59129     try {
59130       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59131     } catch (std::out_of_range& e) {
59132       {
59133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59134       };
59135     } catch (std::exception& e) {
59136       {
59137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59138       };
59139     } catch (Dali::DaliException e) {
59140       {
59141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59142       };
59143     } catch (...) {
59144       {
59145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59146       };
59147     }
59148   }
59149
59150   jresult = (unsigned long)result;
59151   return jresult;
59152 }
59153
59154
59155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59156   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59157   bool (*arg2)() = (bool (*)()) 0 ;
59158
59159   arg1 = (Dali::Signal< bool () > *)jarg1;
59160   arg2 = (bool (*)())jarg2;
59161   {
59162     try {
59163       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59164     } catch (std::out_of_range& e) {
59165       {
59166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59167       };
59168     } catch (std::exception& e) {
59169       {
59170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59171       };
59172     } catch (Dali::DaliException e) {
59173       {
59174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59175       };
59176     } catch (...) {
59177       {
59178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59179       };
59180     }
59181   }
59182
59183 }
59184
59185
59186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59187   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59188   bool (*arg2)() = (bool (*)()) 0 ;
59189
59190   arg1 = (Dali::Signal< bool () > *)jarg1;
59191   arg2 = (bool (*)())jarg2;
59192   {
59193     try {
59194       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59195     } catch (std::out_of_range& e) {
59196       {
59197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59198       };
59199     } catch (std::exception& e) {
59200       {
59201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59202       };
59203     } catch (Dali::DaliException e) {
59204       {
59205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59206       };
59207     } catch (...) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59210       };
59211     }
59212   }
59213
59214 }
59215
59216
59217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59218   unsigned int jresult ;
59219   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59220   bool result;
59221
59222   arg1 = (Dali::Signal< bool () > *)jarg1;
59223   {
59224     try {
59225       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59226     } catch (std::out_of_range& e) {
59227       {
59228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59229       };
59230     } catch (std::exception& e) {
59231       {
59232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59233       };
59234     } catch (Dali::DaliException e) {
59235       {
59236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59237       };
59238     } catch (...) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59241       };
59242     }
59243   }
59244
59245   jresult = result;
59246   return jresult;
59247 }
59248
59249
59250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59251   void * jresult ;
59252   Dali::Signal< bool () > *result = 0 ;
59253
59254   {
59255     try {
59256       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59257     } catch (std::out_of_range& e) {
59258       {
59259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59260       };
59261     } catch (std::exception& e) {
59262       {
59263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59264       };
59265     } catch (Dali::DaliException e) {
59266       {
59267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59268       };
59269     } catch (...) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59272       };
59273     }
59274   }
59275
59276   jresult = (void *)result;
59277   return jresult;
59278 }
59279
59280
59281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59282   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59283
59284   arg1 = (Dali::Signal< bool () > *)jarg1;
59285   {
59286     try {
59287       delete arg1;
59288     } catch (std::out_of_range& e) {
59289       {
59290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59291       };
59292     } catch (std::exception& e) {
59293       {
59294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59295       };
59296     } catch (Dali::DaliException e) {
59297       {
59298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59299       };
59300     } catch (...) {
59301       {
59302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59303       };
59304     }
59305   }
59306
59307 }
59308
59309
59310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59311   int jresult ;
59312   int result;
59313
59314   {
59315     try {
59316       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (Dali::DaliException e) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59328       };
59329     } catch (...) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59332       };
59333     }
59334   }
59335
59336   jresult = (int)result;
59337   return jresult;
59338 }
59339
59340
59341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59342   int jresult ;
59343   int result;
59344
59345   {
59346     try {
59347       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59348     } catch (std::out_of_range& e) {
59349       {
59350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (std::exception& e) {
59353       {
59354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (Dali::DaliException e) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59359       };
59360     } catch (...) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59363       };
59364     }
59365   }
59366
59367   jresult = (int)result;
59368   return jresult;
59369 }
59370
59371
59372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59373   int jresult ;
59374   int result;
59375
59376   {
59377     try {
59378       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59379     } catch (std::out_of_range& e) {
59380       {
59381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (std::exception& e) {
59384       {
59385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (Dali::DaliException e) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397
59398   jresult = (int)result;
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59404   int jresult ;
59405   int result;
59406
59407   {
59408     try {
59409       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (Dali::DaliException e) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59421       };
59422     } catch (...) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59425       };
59426     }
59427   }
59428
59429   jresult = (int)result;
59430   return jresult;
59431 }
59432
59433
59434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59435   int jresult ;
59436   int result;
59437
59438   {
59439     try {
59440       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59441     } catch (std::out_of_range& e) {
59442       {
59443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (std::exception& e) {
59446       {
59447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (Dali::DaliException e) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59452       };
59453     } catch (...) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59456       };
59457     }
59458   }
59459
59460   jresult = (int)result;
59461   return jresult;
59462 }
59463
59464
59465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59466   int jresult ;
59467   int result;
59468
59469   {
59470     try {
59471       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59472     } catch (std::out_of_range& e) {
59473       {
59474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (std::exception& e) {
59477       {
59478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (Dali::DaliException e) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59483       };
59484     } catch (...) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59487       };
59488     }
59489   }
59490
59491   jresult = (int)result;
59492   return jresult;
59493 }
59494
59495
59496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59497   int jresult ;
59498   int result;
59499
59500   {
59501     try {
59502       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59503     } catch (std::out_of_range& e) {
59504       {
59505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59506       };
59507     } catch (std::exception& e) {
59508       {
59509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (Dali::DaliException e) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59514       };
59515     } catch (...) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59518       };
59519     }
59520   }
59521
59522   jresult = (int)result;
59523   return jresult;
59524 }
59525
59526
59527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59528   int jresult ;
59529   int result;
59530
59531   {
59532     try {
59533       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (Dali::DaliException e) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552
59553   jresult = (int)result;
59554   return jresult;
59555 }
59556
59557
59558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59559   int jresult ;
59560   int result;
59561
59562   {
59563     try {
59564       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59565     } catch (std::out_of_range& e) {
59566       {
59567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (std::exception& e) {
59570       {
59571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (Dali::DaliException e) {
59574       {
59575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59576       };
59577     } catch (...) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59580       };
59581     }
59582   }
59583
59584   jresult = (int)result;
59585   return jresult;
59586 }
59587
59588
59589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59590   int jresult ;
59591   int result;
59592
59593   {
59594     try {
59595       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59596     } catch (std::out_of_range& e) {
59597       {
59598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59599       };
59600     } catch (std::exception& e) {
59601       {
59602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (Dali::DaliException e) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59607       };
59608     } catch (...) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59611       };
59612     }
59613   }
59614
59615   jresult = (int)result;
59616   return jresult;
59617 }
59618
59619
59620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59621   int jresult ;
59622   int result;
59623
59624   {
59625     try {
59626       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59627     } catch (std::out_of_range& e) {
59628       {
59629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (std::exception& e) {
59632       {
59633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (Dali::DaliException e) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59638       };
59639     } catch (...) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59642       };
59643     }
59644   }
59645
59646   jresult = (int)result;
59647   return jresult;
59648 }
59649
59650
59651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59652   int jresult ;
59653   int result;
59654
59655   {
59656     try {
59657       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59658     } catch (std::out_of_range& e) {
59659       {
59660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (std::exception& e) {
59663       {
59664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (Dali::DaliException e) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676
59677   jresult = (int)result;
59678   return jresult;
59679 }
59680
59681
59682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59683   int jresult ;
59684   int result;
59685
59686   {
59687     try {
59688       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59689     } catch (std::out_of_range& e) {
59690       {
59691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59692       };
59693     } catch (std::exception& e) {
59694       {
59695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59696       };
59697     } catch (Dali::DaliException e) {
59698       {
59699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59700       };
59701     } catch (...) {
59702       {
59703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59704       };
59705     }
59706   }
59707
59708   jresult = (int)result;
59709   return jresult;
59710 }
59711
59712
59713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59714   int jresult ;
59715   int result;
59716
59717   {
59718     try {
59719       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59720     } catch (std::out_of_range& e) {
59721       {
59722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59723       };
59724     } catch (std::exception& e) {
59725       {
59726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59727       };
59728     } catch (Dali::DaliException e) {
59729       {
59730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59731       };
59732     } catch (...) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59735       };
59736     }
59737   }
59738
59739   jresult = (int)result;
59740   return jresult;
59741 }
59742
59743
59744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59745   int jresult ;
59746   int result;
59747
59748   {
59749     try {
59750       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59751     } catch (std::out_of_range& e) {
59752       {
59753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59754       };
59755     } catch (std::exception& e) {
59756       {
59757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (Dali::DaliException e) {
59760       {
59761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59762       };
59763     } catch (...) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59766       };
59767     }
59768   }
59769
59770   jresult = (int)result;
59771   return jresult;
59772 }
59773
59774
59775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59776   int jresult ;
59777   int result;
59778
59779   {
59780     try {
59781       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59782     } catch (std::out_of_range& e) {
59783       {
59784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59785       };
59786     } catch (std::exception& e) {
59787       {
59788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59789       };
59790     } catch (Dali::DaliException e) {
59791       {
59792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59793       };
59794     } catch (...) {
59795       {
59796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59797       };
59798     }
59799   }
59800
59801   jresult = (int)result;
59802   return jresult;
59803 }
59804
59805
59806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59807   int jresult ;
59808   int result;
59809
59810   {
59811     try {
59812       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59813     } catch (std::out_of_range& e) {
59814       {
59815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59816       };
59817     } catch (std::exception& e) {
59818       {
59819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (Dali::DaliException e) {
59822       {
59823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59824       };
59825     } catch (...) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59828       };
59829     }
59830   }
59831
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836
59837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59838   int jresult ;
59839   int result;
59840
59841   {
59842     try {
59843       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59844     } catch (std::out_of_range& e) {
59845       {
59846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59847       };
59848     } catch (std::exception& e) {
59849       {
59850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (Dali::DaliException e) {
59853       {
59854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59855       };
59856     } catch (...) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59859       };
59860     }
59861   }
59862
59863   jresult = (int)result;
59864   return jresult;
59865 }
59866
59867
59868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59869   int jresult ;
59870   int result;
59871
59872   {
59873     try {
59874       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59875     } catch (std::out_of_range& e) {
59876       {
59877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59878       };
59879     } catch (std::exception& e) {
59880       {
59881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59882       };
59883     } catch (Dali::DaliException e) {
59884       {
59885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59886       };
59887     } catch (...) {
59888       {
59889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59890       };
59891     }
59892   }
59893
59894   jresult = (int)result;
59895   return jresult;
59896 }
59897
59898
59899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59900   int jresult ;
59901   int result;
59902
59903   {
59904     try {
59905       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59906     } catch (std::out_of_range& e) {
59907       {
59908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59909       };
59910     } catch (std::exception& e) {
59911       {
59912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59913       };
59914     } catch (Dali::DaliException e) {
59915       {
59916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59917       };
59918     } catch (...) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59921       };
59922     }
59923   }
59924
59925   jresult = (int)result;
59926   return jresult;
59927 }
59928
59929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59930   int jresult ;
59931   int result;
59932
59933   {
59934     try {
59935       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59936     } catch (std::out_of_range& e) {
59937       {
59938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59939       };
59940     } catch (std::exception& e) {
59941       {
59942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59943       };
59944     } catch (Dali::DaliException e) {
59945       {
59946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59947       };
59948     } catch (...) {
59949       {
59950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59951       };
59952     }
59953   }
59954
59955   jresult = (int)result;
59956   return jresult;
59957 }
59958
59959
59960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59961   int jresult ;
59962   int result;
59963   {
59964     try
59965     {
59966       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59967     } catch (std::out_of_range& e) {
59968       {
59969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59970       };
59971     } catch (std::exception& e) {
59972       {
59973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59974       };
59975     } catch (Dali::DaliException e) {
59976       {
59977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59978       };
59979     } catch (...) {
59980       {
59981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59982       };
59983     }
59984   }
59985
59986   jresult = (int)result;
59987   return jresult;
59988 }
59989
59990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59991   int jresult ;
59992   int result;
59993   {
59994     try
59995     {
59996       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59997     } catch (std::out_of_range& e) {
59998       {
59999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60000       };
60001     } catch (std::exception& e) {
60002       {
60003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60004       };
60005     } catch (Dali::DaliException e) {
60006       {
60007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60008       };
60009     } catch (...) {
60010       {
60011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60012       };
60013     }
60014   }
60015
60016   jresult = (int)result;
60017   return jresult;
60018 }
60019
60020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60021   int jresult ;
60022   int result;
60023   {
60024     try
60025     {
60026       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60027     } catch (std::out_of_range& e) {
60028       {
60029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60030       };
60031     } catch (std::exception& e) {
60032       {
60033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60034       };
60035     } catch (Dali::DaliException e) {
60036       {
60037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60038       };
60039     } catch (...) {
60040       {
60041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60042       };
60043     }
60044   }
60045
60046   jresult = (int)result;
60047   return jresult;
60048 }
60049
60050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60051   int jresult ;
60052   int result;
60053   {
60054     try
60055     {
60056       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60057     } catch (std::out_of_range& e) {
60058       {
60059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (std::exception& e) {
60062       {
60063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60064       };
60065     } catch (Dali::DaliException e) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60068       };
60069     } catch (...) {
60070       {
60071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60072       };
60073     }
60074   }
60075
60076   jresult = (int)result;
60077   return jresult;
60078 }
60079
60080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60081   int jresult ;
60082   int result;
60083   {
60084     try
60085     {
60086       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60087     } catch (std::out_of_range& e) {
60088       {
60089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (std::exception& e) {
60092       {
60093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60094       };
60095     } catch (Dali::DaliException e) {
60096       {
60097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60098       };
60099     } catch (...) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60102       };
60103     }
60104   }
60105
60106   jresult = (int)result;
60107   return jresult;
60108 }
60109
60110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60111   int jresult ;
60112   int result;
60113
60114   {
60115     try {
60116       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60117     } catch (std::out_of_range& e) {
60118       {
60119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60120       };
60121     } catch (std::exception& e) {
60122       {
60123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60124       };
60125     } catch (Dali::DaliException e) {
60126       {
60127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60128       };
60129     } catch (...) {
60130       {
60131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60132       };
60133     }
60134   }
60135
60136   jresult = (int)result;
60137   return jresult;
60138 }
60139
60140
60141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60142   int jresult ;
60143   int result;
60144
60145   {
60146     try {
60147       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60148     } catch (std::out_of_range& e) {
60149       {
60150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60151       };
60152     } catch (std::exception& e) {
60153       {
60154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60155       };
60156     } catch (Dali::DaliException e) {
60157       {
60158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60159       };
60160     } catch (...) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60163       };
60164     }
60165   }
60166
60167   jresult = (int)result;
60168   return jresult;
60169 }
60170
60171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60172   int jresult ;
60173   int result;
60174   {
60175     try
60176     {
60177       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60178     } catch (std::out_of_range& e) {
60179       {
60180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60181       };
60182     } catch (std::exception& e) {
60183       {
60184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60185       };
60186     } catch (...) {
60187       {
60188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60189       };
60190     }
60191   }
60192   jresult = (int)result;
60193   return jresult;
60194 }
60195
60196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60197   int jresult ;
60198   int result;
60199   {
60200     try
60201     {
60202       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60203     } catch (std::out_of_range& e) {
60204       {
60205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60206       };
60207     } catch (std::exception& e) {
60208       {
60209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (...) {
60212       {
60213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60214       };
60215     }
60216   }
60217   jresult = (int)result;
60218   return jresult;
60219 }
60220
60221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60222   int jresult ;
60223   int result;
60224   {
60225     try
60226     {
60227       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60228     } catch (std::out_of_range& e) {
60229       {
60230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60231       };
60232     } catch (std::exception& e) {
60233       {
60234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60239       };
60240     }
60241   }
60242   jresult = (int)result;
60243   return jresult;
60244 }
60245
60246
60247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60248   int jresult ;
60249   int result;
60250   {
60251     try
60252     {
60253       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60254     } catch (std::out_of_range& e) {
60255       {
60256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60257       };
60258     } catch (std::exception& e) {
60259       {
60260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60261       };
60262     } catch (...) {
60263       {
60264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60265       };
60266     }
60267   }
60268   jresult = (int)result;
60269   return jresult;
60270 }
60271
60272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60273   int jresult ;
60274   int result;
60275   {
60276     try
60277     {
60278       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60279     } catch (std::out_of_range& e) {
60280       {
60281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (std::exception& e) {
60284       {
60285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (...) {
60288       {
60289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60290       };
60291     }
60292   }
60293   jresult = (int)result;
60294   return jresult;
60295 }
60296
60297
60298
60299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60300   int jresult ;
60301   int result;
60302
60303   {
60304     try {
60305       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60306     } catch (std::out_of_range& e) {
60307       {
60308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60309       };
60310     } catch (std::exception& e) {
60311       {
60312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60313       };
60314     } catch (Dali::DaliException e) {
60315       {
60316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60317       };
60318     } catch (...) {
60319       {
60320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60321       };
60322     }
60323   }
60324
60325   jresult = (int)result;
60326   return jresult;
60327 }
60328
60329
60330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60331   int jresult ;
60332   int result;
60333
60334   {
60335     try {
60336       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60337     } catch (std::out_of_range& e) {
60338       {
60339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60340       };
60341     } catch (std::exception& e) {
60342       {
60343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60344       };
60345     } catch (Dali::DaliException e) {
60346       {
60347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60348       };
60349     } catch (...) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60352       };
60353     }
60354   }
60355
60356   jresult = (int)result;
60357   return jresult;
60358 }
60359
60360
60361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60362   int jresult ;
60363   int result;
60364
60365   {
60366     try {
60367       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60368     } catch (std::out_of_range& e) {
60369       {
60370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60371       };
60372     } catch (std::exception& e) {
60373       {
60374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (Dali::DaliException e) {
60377       {
60378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60379       };
60380     } catch (...) {
60381       {
60382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60383       };
60384     }
60385   }
60386
60387   jresult = (int)result;
60388   return jresult;
60389 }
60390
60391
60392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60393   int jresult ;
60394   int result;
60395
60396   {
60397     try {
60398       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60399     } catch (std::out_of_range& e) {
60400       {
60401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60402       };
60403     } catch (std::exception& e) {
60404       {
60405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60406       };
60407     } catch (Dali::DaliException e) {
60408       {
60409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60410       };
60411     } catch (...) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60414       };
60415     }
60416   }
60417
60418   jresult = (int)result;
60419   return jresult;
60420 }
60421
60422
60423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60424   int jresult ;
60425   int result;
60426
60427   {
60428     try {
60429       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60430     } catch (std::out_of_range& e) {
60431       {
60432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60433       };
60434     } catch (std::exception& e) {
60435       {
60436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60437       };
60438     } catch (Dali::DaliException e) {
60439       {
60440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60441       };
60442     } catch (...) {
60443       {
60444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60445       };
60446     }
60447   }
60448
60449   jresult = (int)result;
60450   return jresult;
60451 }
60452
60453
60454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60455   int jresult ;
60456   int result;
60457
60458   {
60459     try {
60460       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60468       };
60469     } catch (Dali::DaliException e) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60472       };
60473     } catch (...) {
60474       {
60475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60476       };
60477     }
60478   }
60479
60480   jresult = (int)result;
60481   return jresult;
60482 }
60483
60484
60485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60486   int jresult ;
60487   int result;
60488
60489   {
60490     try {
60491       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60492     } catch (std::out_of_range& e) {
60493       {
60494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (std::exception& e) {
60497       {
60498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60499       };
60500     } catch (Dali::DaliException e) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60503       };
60504     } catch (...) {
60505       {
60506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60507       };
60508     }
60509   }
60510
60511   jresult = (int)result;
60512   return jresult;
60513 }
60514
60515 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60516   int jresult ;
60517   int result;
60518
60519   {
60520     try {
60521       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60522     } catch (std::out_of_range& e) {
60523       {
60524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60525       };
60526     } catch (std::exception& e) {
60527       {
60528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60529       };
60530     } catch (...) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60533       };
60534     }
60535   }
60536   jresult = (int)result;
60537   return jresult;
60538 }
60539
60540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60541   int jresult ;
60542   int result;
60543
60544   {
60545     try {
60546       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60547     } catch (std::out_of_range& e) {
60548       {
60549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60550       };
60551     } catch (std::exception& e) {
60552       {
60553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (Dali::DaliException e) {
60556       {
60557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60558       };
60559     } catch (...) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60562       };
60563     }
60564   }
60565
60566   jresult = (int)result;
60567   return jresult;
60568 }
60569
60570
60571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60572   int jresult ;
60573   int result;
60574
60575   {
60576     try {
60577       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60578     } catch (std::out_of_range& e) {
60579       {
60580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60581       };
60582     } catch (std::exception& e) {
60583       {
60584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (Dali::DaliException e) {
60587       {
60588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60593       };
60594     }
60595   }
60596
60597   jresult = (int)result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60603   int jresult ;
60604   int result;
60605
60606   {
60607     try {
60608       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (Dali::DaliException e) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60620       };
60621     } catch (...) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60624       };
60625     }
60626   }
60627
60628   jresult = (int)result;
60629   return jresult;
60630 }
60631
60632
60633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60634   int jresult ;
60635   int result;
60636
60637   {
60638     try {
60639       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60640     } catch (std::out_of_range& e) {
60641       {
60642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60643       };
60644     } catch (std::exception& e) {
60645       {
60646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (Dali::DaliException e) {
60649       {
60650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60651       };
60652     } catch (...) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60655       };
60656     }
60657   }
60658
60659   jresult = (int)result;
60660   return jresult;
60661 }
60662
60663
60664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60665   int jresult ;
60666   int result;
60667
60668   {
60669     try {
60670       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60671     } catch (std::out_of_range& e) {
60672       {
60673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (std::exception& e) {
60676       {
60677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (Dali::DaliException e) {
60680       {
60681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60686       };
60687     }
60688   }
60689
60690   jresult = (int)result;
60691   return jresult;
60692 }
60693
60694
60695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60696   int jresult ;
60697   int result;
60698
60699   {
60700     try {
60701       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60702     } catch (std::out_of_range& e) {
60703       {
60704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60705       };
60706     } catch (std::exception& e) {
60707       {
60708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (Dali::DaliException e) {
60711       {
60712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60713       };
60714     } catch (...) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60717       };
60718     }
60719   }
60720
60721   jresult = (int)result;
60722   return jresult;
60723 }
60724
60725
60726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60727   int jresult ;
60728   int result;
60729
60730   {
60731     try {
60732       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60733     } catch (std::out_of_range& e) {
60734       {
60735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60736       };
60737     } catch (std::exception& e) {
60738       {
60739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (Dali::DaliException e) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60744       };
60745     } catch (...) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60748       };
60749     }
60750   }
60751
60752   jresult = (int)result;
60753   return jresult;
60754 }
60755
60756
60757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60758   int jresult ;
60759   int result;
60760
60761   {
60762     try {
60763       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60764     } catch (std::out_of_range& e) {
60765       {
60766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (std::exception& e) {
60769       {
60770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (Dali::DaliException e) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60775       };
60776     } catch (...) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60779       };
60780     }
60781   }
60782
60783   jresult = (int)result;
60784   return jresult;
60785 }
60786
60787
60788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60789   int jresult ;
60790   int result;
60791
60792   {
60793     try {
60794       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60795     } catch (std::out_of_range& e) {
60796       {
60797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (std::exception& e) {
60800       {
60801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (Dali::DaliException e) {
60804       {
60805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60806       };
60807     } catch (...) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60810       };
60811     }
60812   }
60813
60814   jresult = (int)result;
60815   return jresult;
60816 }
60817
60818
60819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60820   int jresult ;
60821   int result;
60822
60823   {
60824     try {
60825       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60826     } catch (std::out_of_range& e) {
60827       {
60828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (std::exception& e) {
60831       {
60832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (Dali::DaliException e) {
60835       {
60836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60837       };
60838     } catch (...) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60841       };
60842     }
60843   }
60844
60845   jresult = (int)result;
60846   return jresult;
60847 }
60848
60849
60850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60851   int jresult ;
60852   int result;
60853
60854   {
60855     try {
60856       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60857     } catch (std::out_of_range& e) {
60858       {
60859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (std::exception& e) {
60862       {
60863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (Dali::DaliException e) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60868       };
60869     } catch (...) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60872       };
60873     }
60874   }
60875
60876   jresult = (int)result;
60877   return jresult;
60878 }
60879
60880
60881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60882   int jresult ;
60883   int result;
60884
60885   {
60886     try {
60887       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60888     } catch (std::out_of_range& e) {
60889       {
60890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (std::exception& e) {
60893       {
60894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (Dali::DaliException e) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60899       };
60900     } catch (...) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60903       };
60904     }
60905   }
60906
60907   jresult = (int)result;
60908   return jresult;
60909 }
60910
60911
60912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60913   int jresult ;
60914   int result;
60915
60916   {
60917     try {
60918       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60919     } catch (std::out_of_range& e) {
60920       {
60921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60922       };
60923     } catch (std::exception& e) {
60924       {
60925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (Dali::DaliException e) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60930       };
60931     } catch (...) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60934       };
60935     }
60936   }
60937
60938   jresult = (int)result;
60939   return jresult;
60940 }
60941
60942
60943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60944   int jresult ;
60945   int result;
60946
60947   {
60948     try {
60949       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60950     } catch (std::out_of_range& e) {
60951       {
60952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (std::exception& e) {
60955       {
60956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (Dali::DaliException e) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60961       };
60962     } catch (...) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60965       };
60966     }
60967   }
60968
60969   jresult = (int)result;
60970   return jresult;
60971 }
60972
60973
60974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60975   int jresult ;
60976   int result;
60977
60978   {
60979     try {
60980       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60981     } catch (std::out_of_range& e) {
60982       {
60983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60984       };
60985     } catch (std::exception& e) {
60986       {
60987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (Dali::DaliException e) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60992       };
60993     } catch (...) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60996       };
60997     }
60998   }
60999
61000   jresult = (int)result;
61001   return jresult;
61002 }
61003
61004
61005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61006   int jresult ;
61007   int result;
61008
61009   {
61010     try {
61011       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61012     } catch (std::out_of_range& e) {
61013       {
61014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (std::exception& e) {
61017       {
61018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (Dali::DaliException e) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61023       };
61024     } catch (...) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61027       };
61028     }
61029   }
61030
61031   jresult = (int)result;
61032   return jresult;
61033 }
61034
61035
61036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61037   int jresult ;
61038   int result;
61039
61040   {
61041     try {
61042       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61043     } catch (std::out_of_range& e) {
61044       {
61045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (std::exception& e) {
61048       {
61049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (Dali::DaliException e) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61054       };
61055     } catch (...) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61058       };
61059     }
61060   }
61061
61062   jresult = (int)result;
61063   return jresult;
61064 }
61065
61066
61067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61068   int jresult ;
61069   int result;
61070
61071   {
61072     try {
61073       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61074     } catch (std::out_of_range& e) {
61075       {
61076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61077       };
61078     } catch (std::exception& e) {
61079       {
61080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (Dali::DaliException e) {
61083       {
61084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61085       };
61086     } catch (...) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61089       };
61090     }
61091   }
61092
61093   jresult = (int)result;
61094   return jresult;
61095 }
61096
61097
61098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61099   int jresult ;
61100   int result;
61101
61102   {
61103     try {
61104       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61105     } catch (std::out_of_range& e) {
61106       {
61107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (std::exception& e) {
61110       {
61111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (Dali::DaliException e) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61116       };
61117     } catch (...) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61120       };
61121     }
61122   }
61123
61124   jresult = (int)result;
61125   return jresult;
61126 }
61127
61128
61129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61130   int jresult ;
61131   int result;
61132
61133   {
61134     try {
61135       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
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 = (int)result;
61156   return jresult;
61157 }
61158
61159
61160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61161   int jresult ;
61162   int result;
61163
61164   {
61165     try {
61166       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61167     } catch (std::out_of_range& e) {
61168       {
61169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61170       };
61171     } catch (std::exception& e) {
61172       {
61173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (Dali::DaliException e) {
61176       {
61177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61178       };
61179     } catch (...) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61182       };
61183     }
61184   }
61185
61186   jresult = (int)result;
61187   return jresult;
61188 }
61189
61190
61191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61192   int jresult ;
61193   int result;
61194
61195   {
61196     try {
61197       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61198     } catch (std::out_of_range& e) {
61199       {
61200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61201       };
61202     } catch (std::exception& e) {
61203       {
61204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61205       };
61206     } catch (Dali::DaliException e) {
61207       {
61208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61209       };
61210     } catch (...) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61213       };
61214     }
61215   }
61216
61217   jresult = (int)result;
61218   return jresult;
61219 }
61220
61221
61222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61223   int jresult ;
61224   int result;
61225
61226   {
61227     try {
61228       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61229     } catch (std::out_of_range& e) {
61230       {
61231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61232       };
61233     } catch (std::exception& e) {
61234       {
61235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61236       };
61237     } catch (Dali::DaliException e) {
61238       {
61239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61240       };
61241     } catch (...) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61244       };
61245     }
61246   }
61247
61248   jresult = (int)result;
61249   return jresult;
61250 }
61251
61252
61253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61254   int jresult ;
61255   int result;
61256
61257   {
61258     try {
61259       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61260     } catch (std::out_of_range& e) {
61261       {
61262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (std::exception& e) {
61265       {
61266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61267       };
61268     } catch (Dali::DaliException e) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61271       };
61272     } catch (...) {
61273       {
61274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61275       };
61276     }
61277   }
61278
61279   jresult = (int)result;
61280   return jresult;
61281 }
61282
61283
61284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61285   int jresult ;
61286   int result;
61287
61288   {
61289     try {
61290       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61291     } catch (std::out_of_range& e) {
61292       {
61293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (std::exception& e) {
61296       {
61297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61298       };
61299     } catch (Dali::DaliException e) {
61300       {
61301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61302       };
61303     } catch (...) {
61304       {
61305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61306       };
61307     }
61308   }
61309
61310   jresult = (int)result;
61311   return jresult;
61312 }
61313
61314
61315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61316   int jresult ;
61317   int result;
61318
61319   {
61320     try {
61321       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61322     } catch (std::out_of_range& e) {
61323       {
61324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (std::exception& e) {
61327       {
61328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61329       };
61330     } catch (Dali::DaliException e) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61333       };
61334     } catch (...) {
61335       {
61336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61337       };
61338     }
61339   }
61340
61341   jresult = (int)result;
61342   return jresult;
61343 }
61344
61345
61346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61347   int jresult ;
61348   int result;
61349
61350   {
61351     try {
61352       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61353     } catch (std::out_of_range& e) {
61354       {
61355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (std::exception& e) {
61358       {
61359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61360       };
61361     } catch (Dali::DaliException e) {
61362       {
61363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61364       };
61365     } catch (...) {
61366       {
61367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61368       };
61369     }
61370   }
61371
61372   jresult = (int)result;
61373   return jresult;
61374 }
61375
61376
61377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61378   int jresult ;
61379   int result;
61380
61381   {
61382     try {
61383       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61384     } catch (std::out_of_range& e) {
61385       {
61386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61387       };
61388     } catch (std::exception& e) {
61389       {
61390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (Dali::DaliException e) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61399       };
61400     }
61401   }
61402
61403   jresult = (int)result;
61404   return jresult;
61405 }
61406
61407
61408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61409   void * jresult ;
61410   Dali::Toolkit::Builder *result = 0 ;
61411
61412   {
61413     try {
61414       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61415     } catch (std::out_of_range& e) {
61416       {
61417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61418       };
61419     } catch (std::exception& e) {
61420       {
61421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61422       };
61423     } catch (Dali::DaliException e) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61426       };
61427     } catch (...) {
61428       {
61429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61430       };
61431     }
61432   }
61433
61434   jresult = (void *)result;
61435   return jresult;
61436 }
61437
61438
61439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61440   void * jresult ;
61441   Dali::Toolkit::Builder result;
61442
61443   {
61444     try {
61445       result = Dali::Toolkit::Builder::New();
61446     } catch (std::out_of_range& e) {
61447       {
61448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (std::exception& e) {
61451       {
61452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (Dali::DaliException e) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61457       };
61458     } catch (...) {
61459       {
61460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61461       };
61462     }
61463   }
61464
61465   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61466   return jresult;
61467 }
61468
61469
61470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61471   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61472
61473   arg1 = (Dali::Toolkit::Builder *)jarg1;
61474   {
61475     try {
61476       delete arg1;
61477     } catch (std::out_of_range& e) {
61478       {
61479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61480       };
61481     } catch (std::exception& e) {
61482       {
61483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61484       };
61485     } catch (Dali::DaliException e) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61488       };
61489     } catch (...) {
61490       {
61491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61492       };
61493     }
61494   }
61495
61496 }
61497
61498
61499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61500   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61501   std::string *arg2 = 0 ;
61502   Dali::Toolkit::Builder::UIFormat arg3 ;
61503
61504   arg1 = (Dali::Toolkit::Builder *)jarg1;
61505   if (!jarg2) {
61506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61507     return ;
61508   }
61509   std::string arg2_str(jarg2);
61510   arg2 = &arg2_str;
61511   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61512   {
61513     try {
61514       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61515     } catch (std::out_of_range& e) {
61516       {
61517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61518       };
61519     } catch (std::exception& e) {
61520       {
61521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (Dali::DaliException e) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61526       };
61527     } catch (...) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61530       };
61531     }
61532   }
61533
61534
61535   //argout typemap for const std::string&
61536
61537 }
61538
61539
61540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61541   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61542   std::string *arg2 = 0 ;
61543
61544   arg1 = (Dali::Toolkit::Builder *)jarg1;
61545   if (!jarg2) {
61546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61547     return ;
61548   }
61549   std::string arg2_str(jarg2);
61550   arg2 = &arg2_str;
61551   {
61552     try {
61553       (arg1)->LoadFromString((std::string const &)*arg2);
61554     } catch (std::out_of_range& e) {
61555       {
61556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61557       };
61558     } catch (std::exception& e) {
61559       {
61560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61561       };
61562     } catch (Dali::DaliException e) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61565       };
61566     } catch (...) {
61567       {
61568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61569       };
61570     }
61571   }
61572
61573
61574   //argout typemap for const std::string&
61575
61576 }
61577
61578
61579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61580   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61581   Dali::Property::Map *arg2 = 0 ;
61582
61583   arg1 = (Dali::Toolkit::Builder *)jarg1;
61584   arg2 = (Dali::Property::Map *)jarg2;
61585   if (!arg2) {
61586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61587     return ;
61588   }
61589   {
61590     try {
61591       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61592     } catch (std::out_of_range& e) {
61593       {
61594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61595       };
61596     } catch (std::exception& e) {
61597       {
61598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61599       };
61600     } catch (Dali::DaliException e) {
61601       {
61602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61603       };
61604     } catch (...) {
61605       {
61606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61607       };
61608     }
61609   }
61610
61611 }
61612
61613
61614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61616   std::string *arg2 = 0 ;
61617   Dali::Property::Value *arg3 = 0 ;
61618
61619   arg1 = (Dali::Toolkit::Builder *)jarg1;
61620   if (!jarg2) {
61621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61622     return ;
61623   }
61624   std::string arg2_str(jarg2);
61625   arg2 = &arg2_str;
61626   arg3 = (Dali::Property::Value *)jarg3;
61627   if (!arg3) {
61628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61629     return ;
61630   }
61631   {
61632     try {
61633       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61634     } catch (std::out_of_range& e) {
61635       {
61636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61637       };
61638     } catch (std::exception& e) {
61639       {
61640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61641       };
61642     } catch (Dali::DaliException e) {
61643       {
61644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61645       };
61646     } catch (...) {
61647       {
61648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61649       };
61650     }
61651   }
61652
61653
61654   //argout typemap for const std::string&
61655
61656 }
61657
61658
61659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61660   void * jresult ;
61661   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61662   Dali::Property::Map *result = 0 ;
61663
61664   arg1 = (Dali::Toolkit::Builder *)jarg1;
61665   {
61666     try {
61667       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61668     } catch (std::out_of_range& e) {
61669       {
61670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (std::exception& e) {
61673       {
61674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61675       };
61676     } catch (Dali::DaliException e) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61679       };
61680     } catch (...) {
61681       {
61682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61683       };
61684     }
61685   }
61686
61687   jresult = (void *)result;
61688   return jresult;
61689 }
61690
61691
61692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61693   void * jresult ;
61694   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61695   std::string *arg2 = 0 ;
61696   Dali::Property::Value *result = 0 ;
61697
61698   arg1 = (Dali::Toolkit::Builder *)jarg1;
61699   if (!jarg2) {
61700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61701     return 0;
61702   }
61703   std::string arg2_str(jarg2);
61704   arg2 = &arg2_str;
61705   {
61706     try {
61707       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61708     } catch (std::out_of_range& e) {
61709       {
61710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61711       };
61712     } catch (std::exception& e) {
61713       {
61714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61715       };
61716     } catch (Dali::DaliException e) {
61717       {
61718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61719       };
61720     } catch (...) {
61721       {
61722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61723       };
61724     }
61725   }
61726
61727   jresult = (void *)result;
61728
61729   //argout typemap for const std::string&
61730
61731   return jresult;
61732 }
61733
61734
61735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61736   void * jresult ;
61737   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61738   std::string *arg2 = 0 ;
61739   Dali::Animation result;
61740
61741   arg1 = (Dali::Toolkit::Builder *)jarg1;
61742   if (!jarg2) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61744     return 0;
61745   }
61746   std::string arg2_str(jarg2);
61747   arg2 = &arg2_str;
61748   {
61749     try {
61750       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61751     } catch (std::out_of_range& e) {
61752       {
61753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61754       };
61755     } catch (std::exception& e) {
61756       {
61757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61758       };
61759     } catch (Dali::DaliException e) {
61760       {
61761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61762       };
61763     } catch (...) {
61764       {
61765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61766       };
61767     }
61768   }
61769
61770   jresult = new Dali::Animation((const Dali::Animation &)result);
61771
61772   //argout typemap for const std::string&
61773
61774   return jresult;
61775 }
61776
61777
61778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61779   void * jresult ;
61780   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61781   std::string *arg2 = 0 ;
61782   Dali::Property::Map *arg3 = 0 ;
61783   Dali::Animation result;
61784
61785   arg1 = (Dali::Toolkit::Builder *)jarg1;
61786   if (!jarg2) {
61787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61788     return 0;
61789   }
61790   std::string arg2_str(jarg2);
61791   arg2 = &arg2_str;
61792   arg3 = (Dali::Property::Map *)jarg3;
61793   if (!arg3) {
61794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61795     return 0;
61796   }
61797   {
61798     try {
61799       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61800     } catch (std::out_of_range& e) {
61801       {
61802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (std::exception& e) {
61805       {
61806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61807       };
61808     } catch (Dali::DaliException e) {
61809       {
61810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61811       };
61812     } catch (...) {
61813       {
61814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61815       };
61816     }
61817   }
61818
61819   jresult = new Dali::Animation((const Dali::Animation &)result);
61820
61821   //argout typemap for const std::string&
61822
61823   return jresult;
61824 }
61825
61826
61827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61828   void * jresult ;
61829   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61830   std::string *arg2 = 0 ;
61831   Dali::Actor arg3 ;
61832   Dali::Actor *argp3 ;
61833   Dali::Animation result;
61834
61835   arg1 = (Dali::Toolkit::Builder *)jarg1;
61836   if (!jarg2) {
61837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61838     return 0;
61839   }
61840   std::string arg2_str(jarg2);
61841   arg2 = &arg2_str;
61842   argp3 = (Dali::Actor *)jarg3;
61843   if (!argp3) {
61844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61845     return 0;
61846   }
61847   arg3 = *argp3;
61848   {
61849     try {
61850       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61851     } catch (std::out_of_range& e) {
61852       {
61853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61854       };
61855     } catch (std::exception& e) {
61856       {
61857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61858       };
61859     } catch (Dali::DaliException e) {
61860       {
61861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61862       };
61863     } catch (...) {
61864       {
61865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61866       };
61867     }
61868   }
61869
61870   jresult = new Dali::Animation((const Dali::Animation &)result);
61871
61872   //argout typemap for const std::string&
61873
61874   return jresult;
61875 }
61876
61877
61878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61879   void * jresult ;
61880   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61881   std::string *arg2 = 0 ;
61882   Dali::Property::Map *arg3 = 0 ;
61883   Dali::Actor arg4 ;
61884   Dali::Actor *argp4 ;
61885   Dali::Animation result;
61886
61887   arg1 = (Dali::Toolkit::Builder *)jarg1;
61888   if (!jarg2) {
61889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61890     return 0;
61891   }
61892   std::string arg2_str(jarg2);
61893   arg2 = &arg2_str;
61894   arg3 = (Dali::Property::Map *)jarg3;
61895   if (!arg3) {
61896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61897     return 0;
61898   }
61899   argp4 = (Dali::Actor *)jarg4;
61900   if (!argp4) {
61901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61902     return 0;
61903   }
61904   arg4 = *argp4;
61905   {
61906     try {
61907       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61908     } catch (std::out_of_range& e) {
61909       {
61910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61911       };
61912     } catch (std::exception& e) {
61913       {
61914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61915       };
61916     } catch (Dali::DaliException e) {
61917       {
61918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61919       };
61920     } catch (...) {
61921       {
61922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61923       };
61924     }
61925   }
61926
61927   jresult = new Dali::Animation((const Dali::Animation &)result);
61928
61929   //argout typemap for const std::string&
61930
61931   return jresult;
61932 }
61933
61934
61935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61936   void * jresult ;
61937   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61938   std::string *arg2 = 0 ;
61939   Dali::BaseHandle result;
61940
61941   arg1 = (Dali::Toolkit::Builder *)jarg1;
61942   if (!jarg2) {
61943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61944     return 0;
61945   }
61946   std::string arg2_str(jarg2);
61947   arg2 = &arg2_str;
61948   {
61949     try {
61950       result = (arg1)->Create((std::string const &)*arg2);
61951     } catch (std::out_of_range& e) {
61952       {
61953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61954       };
61955     } catch (std::exception& e) {
61956       {
61957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61958       };
61959     } catch (Dali::DaliException e) {
61960       {
61961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61962       };
61963     } catch (...) {
61964       {
61965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61966       };
61967     }
61968   }
61969
61970   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61971
61972   //argout typemap for const std::string&
61973
61974   return jresult;
61975 }
61976
61977
61978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61979   void * jresult ;
61980   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61981   std::string *arg2 = 0 ;
61982   Dali::Property::Map *arg3 = 0 ;
61983   Dali::BaseHandle result;
61984
61985   arg1 = (Dali::Toolkit::Builder *)jarg1;
61986   if (!jarg2) {
61987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61988     return 0;
61989   }
61990   std::string arg2_str(jarg2);
61991   arg2 = &arg2_str;
61992   arg3 = (Dali::Property::Map *)jarg3;
61993   if (!arg3) {
61994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61995     return 0;
61996   }
61997   {
61998     try {
61999       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62000     } catch (std::out_of_range& e) {
62001       {
62002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62003       };
62004     } catch (std::exception& e) {
62005       {
62006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62007       };
62008     } catch (Dali::DaliException e) {
62009       {
62010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62011       };
62012     } catch (...) {
62013       {
62014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62015       };
62016     }
62017   }
62018
62019   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62020
62021   //argout typemap for const std::string&
62022
62023   return jresult;
62024 }
62025
62026
62027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62028   void * jresult ;
62029   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62030   std::string *arg2 = 0 ;
62031   Dali::BaseHandle result;
62032
62033   arg1 = (Dali::Toolkit::Builder *)jarg1;
62034   if (!jarg2) {
62035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62036     return 0;
62037   }
62038   std::string arg2_str(jarg2);
62039   arg2 = &arg2_str;
62040   {
62041     try {
62042       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62043     } catch (std::out_of_range& e) {
62044       {
62045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62046       };
62047     } catch (std::exception& e) {
62048       {
62049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62050       };
62051     } catch (Dali::DaliException e) {
62052       {
62053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62054       };
62055     } catch (...) {
62056       {
62057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62058       };
62059     }
62060   }
62061
62062   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62063
62064   //argout typemap for const std::string&
62065
62066   return jresult;
62067 }
62068
62069
62070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62071   unsigned int jresult ;
62072   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62073   std::string *arg2 = 0 ;
62074   Dali::Handle *arg3 = 0 ;
62075   bool result;
62076
62077   arg1 = (Dali::Toolkit::Builder *)jarg1;
62078   if (!jarg2) {
62079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62080     return 0;
62081   }
62082   std::string arg2_str(jarg2);
62083   arg2 = &arg2_str;
62084   arg3 = (Dali::Handle *)jarg3;
62085   if (!arg3) {
62086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62087     return 0;
62088   }
62089   {
62090     try {
62091       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62092     } catch (std::out_of_range& e) {
62093       {
62094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62095       };
62096     } catch (std::exception& e) {
62097       {
62098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62099       };
62100     } catch (Dali::DaliException e) {
62101       {
62102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62103       };
62104     } catch (...) {
62105       {
62106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62107       };
62108     }
62109   }
62110
62111   jresult = result;
62112
62113   //argout typemap for const std::string&
62114
62115   return jresult;
62116 }
62117
62118
62119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62120   unsigned int jresult ;
62121   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62122   Dali::Handle *arg2 = 0 ;
62123   std::string *arg3 = 0 ;
62124   bool result;
62125
62126   arg1 = (Dali::Toolkit::Builder *)jarg1;
62127   arg2 = (Dali::Handle *)jarg2;
62128   if (!arg2) {
62129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62130     return 0;
62131   }
62132   if (!jarg3) {
62133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62134     return 0;
62135   }
62136   std::string arg3_str(jarg3);
62137   arg3 = &arg3_str;
62138   {
62139     try {
62140       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62141     } catch (std::out_of_range& e) {
62142       {
62143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62144       };
62145     } catch (std::exception& e) {
62146       {
62147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62148       };
62149     } catch (Dali::DaliException e) {
62150       {
62151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62152       };
62153     } catch (...) {
62154       {
62155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62156       };
62157     }
62158   }
62159
62160   jresult = result;
62161
62162   //argout typemap for const std::string&
62163
62164   return jresult;
62165 }
62166
62167
62168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62169   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62170   Dali::Actor arg2 ;
62171   Dali::Actor *argp2 ;
62172
62173   arg1 = (Dali::Toolkit::Builder *)jarg1;
62174   argp2 = (Dali::Actor *)jarg2;
62175   if (!argp2) {
62176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62177     return ;
62178   }
62179   arg2 = *argp2;
62180   {
62181     try {
62182       (arg1)->AddActors(arg2);
62183     } catch (std::out_of_range& e) {
62184       {
62185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62186       };
62187     } catch (std::exception& e) {
62188       {
62189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62190       };
62191     } catch (Dali::DaliException e) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62194       };
62195     } catch (...) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62198       };
62199     }
62200   }
62201
62202 }
62203
62204
62205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62206   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62207   std::string *arg2 = 0 ;
62208   Dali::Actor arg3 ;
62209   Dali::Actor *argp3 ;
62210
62211   arg1 = (Dali::Toolkit::Builder *)jarg1;
62212   if (!jarg2) {
62213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62214     return ;
62215   }
62216   std::string arg2_str(jarg2);
62217   arg2 = &arg2_str;
62218   argp3 = (Dali::Actor *)jarg3;
62219   if (!argp3) {
62220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62221     return ;
62222   }
62223   arg3 = *argp3;
62224   {
62225     try {
62226       (arg1)->AddActors((std::string const &)*arg2,arg3);
62227     } catch (std::out_of_range& e) {
62228       {
62229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62230       };
62231     } catch (std::exception& e) {
62232       {
62233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62234       };
62235     } catch (Dali::DaliException e) {
62236       {
62237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62238       };
62239     } catch (...) {
62240       {
62241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62242       };
62243     }
62244   }
62245
62246
62247   //argout typemap for const std::string&
62248
62249 }
62250
62251
62252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62254   std::string *arg2 = 0 ;
62255
62256   arg1 = (Dali::Toolkit::Builder *)jarg1;
62257   if (!jarg2) {
62258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62259     return ;
62260   }
62261   std::string arg2_str(jarg2);
62262   arg2 = &arg2_str;
62263   {
62264     try {
62265       (arg1)->CreateRenderTask((std::string const &)*arg2);
62266     } catch (std::out_of_range& e) {
62267       {
62268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62269       };
62270     } catch (std::exception& e) {
62271       {
62272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (Dali::DaliException e) {
62275       {
62276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62281       };
62282     }
62283   }
62284
62285
62286   //argout typemap for const std::string&
62287
62288 }
62289
62290
62291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62292   void * jresult ;
62293   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62294   std::string *arg2 = 0 ;
62295   Dali::FrameBufferImage result;
62296
62297   arg1 = (Dali::Toolkit::Builder *)jarg1;
62298   if (!jarg2) {
62299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62300     return 0;
62301   }
62302   std::string arg2_str(jarg2);
62303   arg2 = &arg2_str;
62304   {
62305     try {
62306       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62307     } catch (std::out_of_range& e) {
62308       {
62309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62310       };
62311     } catch (std::exception& e) {
62312       {
62313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62314       };
62315     } catch (Dali::DaliException e) {
62316       {
62317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62318       };
62319     } catch (...) {
62320       {
62321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62322       };
62323     }
62324   }
62325
62326   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62327
62328   //argout typemap for const std::string&
62329
62330   return jresult;
62331 }
62332
62333
62334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62335   void * jresult ;
62336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62337   std::string *arg2 = 0 ;
62338   Dali::Path result;
62339
62340   arg1 = (Dali::Toolkit::Builder *)jarg1;
62341   if (!jarg2) {
62342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62343     return 0;
62344   }
62345   std::string arg2_str(jarg2);
62346   arg2 = &arg2_str;
62347   {
62348     try {
62349       result = (arg1)->GetPath((std::string const &)*arg2);
62350     } catch (std::out_of_range& e) {
62351       {
62352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62353       };
62354     } catch (std::exception& e) {
62355       {
62356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (Dali::DaliException e) {
62359       {
62360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62361       };
62362     } catch (...) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62365       };
62366     }
62367   }
62368
62369   jresult = new Dali::Path((const Dali::Path &)result);
62370
62371   //argout typemap for const std::string&
62372
62373   return jresult;
62374 }
62375
62376
62377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62378   void * jresult ;
62379   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62380   std::string *arg2 = 0 ;
62381   Dali::PathConstrainer result;
62382
62383   arg1 = (Dali::Toolkit::Builder *)jarg1;
62384   if (!jarg2) {
62385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62386     return 0;
62387   }
62388   std::string arg2_str(jarg2);
62389   arg2 = &arg2_str;
62390   {
62391     try {
62392       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62393     } catch (std::out_of_range& e) {
62394       {
62395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (std::exception& e) {
62398       {
62399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (Dali::DaliException e) {
62402       {
62403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62404       };
62405     } catch (...) {
62406       {
62407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62408       };
62409     }
62410   }
62411
62412   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62413
62414   //argout typemap for const std::string&
62415
62416   return jresult;
62417 }
62418
62419
62420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62421   void * jresult ;
62422   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62423   std::string *arg2 = 0 ;
62424   Dali::LinearConstrainer result;
62425
62426   arg1 = (Dali::Toolkit::Builder *)jarg1;
62427   if (!jarg2) {
62428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62429     return 0;
62430   }
62431   std::string arg2_str(jarg2);
62432   arg2 = &arg2_str;
62433   {
62434     try {
62435       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62436     } catch (std::out_of_range& e) {
62437       {
62438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62439       };
62440     } catch (std::exception& e) {
62441       {
62442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62443       };
62444     } catch (Dali::DaliException e) {
62445       {
62446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62447       };
62448     } catch (...) {
62449       {
62450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62451       };
62452     }
62453   }
62454
62455   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62456
62457   //argout typemap for const std::string&
62458
62459   return jresult;
62460 }
62461
62462
62463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62464   void * jresult ;
62465   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62466   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62467
62468   arg1 = (Dali::Toolkit::Builder *)jarg1;
62469   {
62470     try {
62471       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62472     } catch (std::out_of_range& e) {
62473       {
62474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62475       };
62476     } catch (std::exception& e) {
62477       {
62478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62479       };
62480     } catch (Dali::DaliException e) {
62481       {
62482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62483       };
62484     } catch (...) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62487       };
62488     }
62489   }
62490
62491   jresult = (void *)result;
62492   return jresult;
62493 }
62494
62495
62496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62497   void * jresult ;
62498   Dali::Toolkit::TransitionData *result = 0 ;
62499
62500   {
62501     try {
62502       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62503     } catch (std::out_of_range& e) {
62504       {
62505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62506       };
62507     } catch (std::exception& e) {
62508       {
62509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62510       };
62511     } catch (Dali::DaliException e) {
62512       {
62513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62514       };
62515     } catch (...) {
62516       {
62517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62518       };
62519     }
62520   }
62521
62522   jresult = (void *)result;
62523   return jresult;
62524 }
62525
62526
62527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62528   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62529
62530   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62531   {
62532     try {
62533       delete arg1;
62534     } catch (std::out_of_range& e) {
62535       {
62536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62537       };
62538     } catch (std::exception& e) {
62539       {
62540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62541       };
62542     } catch (Dali::DaliException e) {
62543       {
62544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62545       };
62546     } catch (...) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62549       };
62550     }
62551   }
62552
62553 }
62554
62555
62556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62557   void * jresult ;
62558   Dali::Property::Map *arg1 = 0 ;
62559   Dali::Toolkit::TransitionData result;
62560
62561   arg1 = (Dali::Property::Map *)jarg1;
62562   if (!arg1) {
62563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62564     return 0;
62565   }
62566   {
62567     try {
62568       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (Dali::DaliException e) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62580       };
62581     } catch (...) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62584       };
62585     }
62586   }
62587
62588   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62589   return jresult;
62590 }
62591
62592
62593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62594   void * jresult ;
62595   Dali::Property::Array *arg1 = 0 ;
62596   Dali::Toolkit::TransitionData result;
62597
62598   arg1 = (Dali::Property::Array *)jarg1;
62599   if (!arg1) {
62600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62601     return 0;
62602   }
62603   {
62604     try {
62605       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62606     } catch (std::out_of_range& e) {
62607       {
62608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (std::exception& e) {
62611       {
62612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (Dali::DaliException e) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62617       };
62618     } catch (...) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62621       };
62622     }
62623   }
62624
62625   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62626   return jresult;
62627 }
62628
62629
62630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62631   void * jresult ;
62632   Dali::BaseHandle arg1 ;
62633   Dali::BaseHandle *argp1 ;
62634   Dali::Toolkit::TransitionData result;
62635
62636   argp1 = (Dali::BaseHandle *)jarg1;
62637   if (!argp1) {
62638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62639     return 0;
62640   }
62641   arg1 = *argp1;
62642   {
62643     try {
62644       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62645     } catch (std::out_of_range& e) {
62646       {
62647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62648       };
62649     } catch (std::exception& e) {
62650       {
62651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (Dali::DaliException e) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62656       };
62657     } catch (...) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62660       };
62661     }
62662   }
62663
62664   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62665   return jresult;
62666 }
62667
62668
62669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62670   void * jresult ;
62671   Dali::Toolkit::TransitionData *arg1 = 0 ;
62672   Dali::Toolkit::TransitionData *result = 0 ;
62673
62674   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62675   if (!arg1) {
62676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62677     return 0;
62678   }
62679   {
62680     try {
62681       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62682     } catch (std::out_of_range& e) {
62683       {
62684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (std::exception& e) {
62687       {
62688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (Dali::DaliException e) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62697       };
62698     }
62699   }
62700
62701   jresult = (void *)result;
62702   return jresult;
62703 }
62704
62705
62706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62707   void * jresult ;
62708   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62709   Dali::Toolkit::TransitionData *arg2 = 0 ;
62710   Dali::Toolkit::TransitionData *result = 0 ;
62711
62712   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62713   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62714   if (!arg2) {
62715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62716     return 0;
62717   }
62718   {
62719     try {
62720       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62721     } catch (std::out_of_range& e) {
62722       {
62723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62724       };
62725     } catch (std::exception& e) {
62726       {
62727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62728       };
62729     } catch (Dali::DaliException e) {
62730       {
62731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62732       };
62733     } catch (...) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62736       };
62737     }
62738   }
62739
62740   jresult = (void *)result;
62741   return jresult;
62742 }
62743
62744
62745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62746   unsigned long jresult ;
62747   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62748   size_t result;
62749
62750   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62751   {
62752     try {
62753       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62754     } catch (std::out_of_range& e) {
62755       {
62756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62757       };
62758     } catch (std::exception& e) {
62759       {
62760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (Dali::DaliException e) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62765       };
62766     } catch (...) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62769       };
62770     }
62771   }
62772
62773   jresult = (unsigned long)result;
62774   return jresult;
62775 }
62776
62777
62778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62779   void * jresult ;
62780   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62781   size_t arg2 ;
62782   Dali::Property::Map result;
62783
62784   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62785   arg2 = (size_t)jarg2;
62786   {
62787     try {
62788       result = (arg1)->GetAnimatorAt(arg2);
62789     } catch (std::out_of_range& e) {
62790       {
62791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62792       };
62793     } catch (std::exception& e) {
62794       {
62795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (Dali::DaliException e) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62800       };
62801     } catch (...) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62804       };
62805     }
62806   }
62807
62808   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62809   return jresult;
62810 }
62811
62812
62813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62814   void * jresult ;
62815   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62816   Dali::Toolkit::TransitionData *result = 0 ;
62817
62818   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62819   {
62820     try {
62821       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
62822     } catch (std::out_of_range& e) {
62823       {
62824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (std::exception& e) {
62827       {
62828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (Dali::DaliException e) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62833       };
62834     } catch (...) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62837       };
62838     }
62839   }
62840
62841   jresult = (void *)result;
62842   return jresult;
62843 }
62844
62845
62846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62847   int jresult ;
62848   int result;
62849
62850   {
62851     try {
62852       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62853     } catch (std::out_of_range& e) {
62854       {
62855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62856       };
62857     } catch (std::exception& e) {
62858       {
62859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62860       };
62861     } catch (Dali::DaliException e) {
62862       {
62863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62864       };
62865     } catch (...) {
62866       {
62867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62868       };
62869     }
62870   }
62871
62872   jresult = (int)result;
62873   return jresult;
62874 }
62875
62876
62877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62878   int jresult ;
62879   int result;
62880
62881   {
62882     try {
62883       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62884     } catch (std::out_of_range& e) {
62885       {
62886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62887       };
62888     } catch (std::exception& e) {
62889       {
62890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62891       };
62892     } catch (Dali::DaliException e) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62895       };
62896     } catch (...) {
62897       {
62898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62899       };
62900     }
62901   }
62902
62903   jresult = (int)result;
62904   return jresult;
62905 }
62906
62907
62908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62909   int jresult ;
62910   int result;
62911
62912   {
62913     try {
62914       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62915     } catch (std::out_of_range& e) {
62916       {
62917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62918       };
62919     } catch (std::exception& e) {
62920       {
62921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62922       };
62923     } catch (Dali::DaliException e) {
62924       {
62925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62926       };
62927     } catch (...) {
62928       {
62929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62930       };
62931     }
62932   }
62933
62934   jresult = (int)result;
62935   return jresult;
62936 }
62937
62938
62939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62940   int jresult ;
62941   int result;
62942
62943   {
62944     try {
62945       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62946     } catch (std::out_of_range& e) {
62947       {
62948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62949       };
62950     } catch (std::exception& e) {
62951       {
62952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (Dali::DaliException e) {
62955       {
62956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62957       };
62958     } catch (...) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62961       };
62962     }
62963   }
62964
62965   jresult = (int)result;
62966   return jresult;
62967 }
62968
62969
62970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62971   int jresult ;
62972   int result;
62973
62974   {
62975     try {
62976       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62977     } catch (std::out_of_range& e) {
62978       {
62979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62980       };
62981     } catch (std::exception& e) {
62982       {
62983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62984       };
62985     } catch (Dali::DaliException e) {
62986       {
62987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62988       };
62989     } catch (...) {
62990       {
62991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62992       };
62993     }
62994   }
62995
62996   jresult = (int)result;
62997   return jresult;
62998 }
62999
63000
63001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63002   int jresult ;
63003   int result;
63004
63005   {
63006     try {
63007       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63008     } catch (std::out_of_range& e) {
63009       {
63010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63011       };
63012     } catch (std::exception& e) {
63013       {
63014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63015       };
63016     } catch (Dali::DaliException e) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63019       };
63020     } catch (...) {
63021       {
63022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63023       };
63024     }
63025   }
63026
63027   jresult = (int)result;
63028   return jresult;
63029 }
63030
63031
63032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63033   int jresult ;
63034   int result;
63035
63036   {
63037     try {
63038       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63039     } catch (std::out_of_range& e) {
63040       {
63041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63042       };
63043     } catch (std::exception& e) {
63044       {
63045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63046       };
63047     } catch (Dali::DaliException e) {
63048       {
63049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63050       };
63051     } catch (...) {
63052       {
63053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63054       };
63055     }
63056   }
63057
63058   jresult = (int)result;
63059   return jresult;
63060 }
63061
63062
63063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63064   int jresult ;
63065   int result;
63066
63067   {
63068     try {
63069       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63070     } catch (std::out_of_range& e) {
63071       {
63072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63073       };
63074     } catch (std::exception& e) {
63075       {
63076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63077       };
63078     } catch (Dali::DaliException e) {
63079       {
63080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63081       };
63082     } catch (...) {
63083       {
63084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63085       };
63086     }
63087   }
63088
63089   jresult = (int)result;
63090   return jresult;
63091 }
63092
63093
63094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63095   int jresult ;
63096   int result;
63097
63098   {
63099     try {
63100       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63101     } catch (std::out_of_range& e) {
63102       {
63103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63104       };
63105     } catch (std::exception& e) {
63106       {
63107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (Dali::DaliException e) {
63110       {
63111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63112       };
63113     } catch (...) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63116       };
63117     }
63118   }
63119
63120   jresult = (int)result;
63121   return jresult;
63122 }
63123
63124
63125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63126   int jresult ;
63127   int result;
63128
63129   {
63130     try {
63131       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63132     } catch (std::out_of_range& e) {
63133       {
63134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63135       };
63136     } catch (std::exception& e) {
63137       {
63138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (Dali::DaliException e) {
63141       {
63142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63143       };
63144     } catch (...) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63147       };
63148     }
63149   }
63150
63151   jresult = (int)result;
63152   return jresult;
63153 }
63154
63155
63156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63157   int jresult ;
63158   int result;
63159
63160   {
63161     try {
63162       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63163     } catch (std::out_of_range& e) {
63164       {
63165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63166       };
63167     } catch (std::exception& e) {
63168       {
63169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63170       };
63171     } catch (Dali::DaliException e) {
63172       {
63173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63174       };
63175     } catch (...) {
63176       {
63177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63178       };
63179     }
63180   }
63181
63182   jresult = (int)result;
63183   return jresult;
63184 }
63185
63186
63187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63188   int jresult ;
63189   int result;
63190
63191   {
63192     try {
63193       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63194     } catch (std::out_of_range& e) {
63195       {
63196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (std::exception& e) {
63199       {
63200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (Dali::DaliException e) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63205       };
63206     } catch (...) {
63207       {
63208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63209       };
63210     }
63211   }
63212
63213   jresult = (int)result;
63214   return jresult;
63215 }
63216
63217
63218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63219   int jresult ;
63220   int result;
63221
63222   {
63223     try {
63224       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63225     } catch (std::out_of_range& e) {
63226       {
63227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63228       };
63229     } catch (std::exception& e) {
63230       {
63231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63232       };
63233     } catch (Dali::DaliException e) {
63234       {
63235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63236       };
63237     } catch (...) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63240       };
63241     }
63242   }
63243
63244   jresult = (int)result;
63245   return jresult;
63246 }
63247
63248
63249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63250   int jresult ;
63251   int result;
63252
63253   {
63254     try {
63255       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63256     } catch (std::out_of_range& e) {
63257       {
63258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63259       };
63260     } catch (std::exception& e) {
63261       {
63262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (Dali::DaliException e) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63267       };
63268     } catch (...) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63271       };
63272     }
63273   }
63274
63275   jresult = (int)result;
63276   return jresult;
63277 }
63278
63279
63280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63281   void * jresult ;
63282   Dali::Toolkit::Control result;
63283
63284   {
63285     try {
63286       result = Dali::Toolkit::Internal::Control::New();
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (Dali::DaliException e) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63302       };
63303     }
63304   }
63305
63306   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63307   return jresult;
63308 }
63309
63310
63311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63313   std::string *arg2 = 0 ;
63314
63315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63316   if (!jarg2) {
63317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63318     return ;
63319   }
63320   std::string arg2_str(jarg2);
63321   arg2 = &arg2_str;
63322   {
63323     try {
63324       (arg1)->SetStyleName((std::string const &)*arg2);
63325     } catch (std::out_of_range& e) {
63326       {
63327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63328       };
63329     } catch (std::exception& e) {
63330       {
63331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63332       };
63333     } catch (Dali::DaliException e) {
63334       {
63335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63336       };
63337     } catch (...) {
63338       {
63339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63340       };
63341     }
63342   }
63343
63344
63345   //argout typemap for const std::string&
63346
63347 }
63348
63349
63350 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63351   char * jresult ;
63352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63353   std::string *result = 0 ;
63354
63355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63356   {
63357     try {
63358       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63359     } catch (std::out_of_range& e) {
63360       {
63361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (std::exception& e) {
63364       {
63365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63366       };
63367     } catch (Dali::DaliException e) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63370       };
63371     } catch (...) {
63372       {
63373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63374       };
63375     }
63376   }
63377
63378   jresult = SWIG_csharp_string_callback(result->c_str());
63379   return jresult;
63380 }
63381
63382
63383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63385   Dali::Vector4 *arg2 = 0 ;
63386
63387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63388   arg2 = (Dali::Vector4 *)jarg2;
63389   if (!arg2) {
63390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63391     return ;
63392   }
63393   {
63394     try {
63395       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63396     } catch (std::out_of_range& e) {
63397       {
63398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63399       };
63400     } catch (std::exception& e) {
63401       {
63402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63403       };
63404     } catch (Dali::DaliException e) {
63405       {
63406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63407       };
63408     } catch (...) {
63409       {
63410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63411       };
63412     }
63413   }
63414
63415 }
63416
63417
63418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63419   void * jresult ;
63420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63421   Dali::Vector4 result;
63422
63423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63424   {
63425     try {
63426       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63427     } catch (std::out_of_range& e) {
63428       {
63429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63430       };
63431     } catch (std::exception& e) {
63432       {
63433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63434       };
63435     } catch (Dali::DaliException e) {
63436       {
63437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63438       };
63439     } catch (...) {
63440       {
63441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63442       };
63443     }
63444   }
63445
63446   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63447   return jresult;
63448 }
63449
63450
63451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63453   Dali::Image arg2 ;
63454   Dali::Image *argp2 ;
63455
63456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63457   argp2 = (Dali::Image *)jarg2;
63458   if (!argp2) {
63459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63460     return ;
63461   }
63462   arg2 = *argp2;
63463   {
63464     try {
63465       (arg1)->SetBackgroundImage(arg2);
63466     } catch (std::out_of_range& e) {
63467       {
63468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63469       };
63470     } catch (std::exception& e) {
63471       {
63472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (Dali::DaliException e) {
63475       {
63476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63477       };
63478     } catch (...) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63481       };
63482     }
63483   }
63484
63485 }
63486
63487
63488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63490   Dali::Property::Map *arg2 = 0 ;
63491
63492   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63493   arg2 = (Dali::Property::Map *)jarg2;
63494   if (!arg2) {
63495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63496     return ;
63497   }
63498   {
63499     try {
63500       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63501     } catch (std::out_of_range& e) {
63502       {
63503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63504       };
63505     } catch (std::exception& e) {
63506       {
63507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63508       };
63509     } catch (Dali::DaliException e) {
63510       {
63511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63512       };
63513     } catch (...) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63516       };
63517     }
63518   }
63519
63520 }
63521
63522
63523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63525
63526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63527   {
63528     try {
63529       (arg1)->ClearBackground();
63530     } catch (std::out_of_range& e) {
63531       {
63532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63533       };
63534     } catch (std::exception& e) {
63535       {
63536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63537       };
63538     } catch (Dali::DaliException e) {
63539       {
63540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63541       };
63542     } catch (...) {
63543       {
63544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63545       };
63546     }
63547   }
63548
63549 }
63550
63551
63552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63554   Dali::Gesture::Type arg2 ;
63555
63556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63557   arg2 = (Dali::Gesture::Type)jarg2;
63558   {
63559     try {
63560       (arg1)->EnableGestureDetection(arg2);
63561     } catch (std::out_of_range& e) {
63562       {
63563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63564       };
63565     } catch (std::exception& e) {
63566       {
63567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63568       };
63569     } catch (Dali::DaliException e) {
63570       {
63571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63572       };
63573     } catch (...) {
63574       {
63575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63576       };
63577     }
63578   }
63579
63580 }
63581
63582
63583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63584   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63585   Dali::Gesture::Type arg2 ;
63586
63587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63588   arg2 = (Dali::Gesture::Type)jarg2;
63589   {
63590     try {
63591       (arg1)->DisableGestureDetection(arg2);
63592     } catch (std::out_of_range& e) {
63593       {
63594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63595       };
63596     } catch (std::exception& e) {
63597       {
63598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63599       };
63600     } catch (Dali::DaliException e) {
63601       {
63602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63603       };
63604     } catch (...) {
63605       {
63606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63607       };
63608     }
63609   }
63610
63611 }
63612
63613
63614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63615   void * jresult ;
63616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63617   Dali::PinchGestureDetector result;
63618
63619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63620   {
63621     try {
63622       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63623     } catch (std::out_of_range& e) {
63624       {
63625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63626       };
63627     } catch (std::exception& e) {
63628       {
63629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (Dali::DaliException e) {
63632       {
63633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63634       };
63635     } catch (...) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63638       };
63639     }
63640   }
63641
63642   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63643   return jresult;
63644 }
63645
63646
63647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63648   void * jresult ;
63649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63650   Dali::PanGestureDetector result;
63651
63652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63653   {
63654     try {
63655       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63656     } catch (std::out_of_range& e) {
63657       {
63658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63659       };
63660     } catch (std::exception& e) {
63661       {
63662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (Dali::DaliException e) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674
63675   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63676   return jresult;
63677 }
63678
63679
63680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63681   void * jresult ;
63682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63683   Dali::TapGestureDetector result;
63684
63685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63686   {
63687     try {
63688       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (Dali::DaliException e) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63700       };
63701     } catch (...) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63704       };
63705     }
63706   }
63707
63708   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63709   return jresult;
63710 }
63711
63712
63713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63714   void * jresult ;
63715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63716   Dali::LongPressGestureDetector result;
63717
63718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63719   {
63720     try {
63721       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63722     } catch (std::out_of_range& e) {
63723       {
63724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63725       };
63726     } catch (std::exception& e) {
63727       {
63728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63729       };
63730     } catch (Dali::DaliException e) {
63731       {
63732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63733       };
63734     } catch (...) {
63735       {
63736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63737       };
63738     }
63739   }
63740
63741   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63742   return jresult;
63743 }
63744
63745
63746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63748   bool arg2 ;
63749
63750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63751   arg2 = jarg2 ? true : false;
63752   {
63753     try {
63754       (arg1)->SetKeyboardNavigationSupport(arg2);
63755     } catch (std::out_of_range& e) {
63756       {
63757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63758       };
63759     } catch (std::exception& e) {
63760       {
63761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63762       };
63763     } catch (Dali::DaliException e) {
63764       {
63765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63766       };
63767     } catch (...) {
63768       {
63769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63770       };
63771     }
63772   }
63773
63774 }
63775
63776
63777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63778   unsigned int jresult ;
63779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63780   bool result;
63781
63782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63783   {
63784     try {
63785       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63786     } catch (std::out_of_range& e) {
63787       {
63788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63789       };
63790     } catch (std::exception& e) {
63791       {
63792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63793       };
63794     } catch (Dali::DaliException e) {
63795       {
63796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63797       };
63798     } catch (...) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63801       };
63802     }
63803   }
63804
63805   jresult = result;
63806   return jresult;
63807 }
63808
63809
63810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63812
63813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63814   {
63815     try {
63816       (arg1)->SetKeyInputFocus();
63817     } catch (std::out_of_range& e) {
63818       {
63819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63820       };
63821     } catch (std::exception& e) {
63822       {
63823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63824       };
63825     } catch (Dali::DaliException e) {
63826       {
63827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63828       };
63829     } catch (...) {
63830       {
63831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63832       };
63833     }
63834   }
63835
63836 }
63837
63838
63839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63840   unsigned int jresult ;
63841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63842   bool result;
63843
63844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63845   {
63846     try {
63847       result = (bool)(arg1)->HasKeyInputFocus();
63848     } catch (std::out_of_range& e) {
63849       {
63850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63851       };
63852     } catch (std::exception& e) {
63853       {
63854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63855       };
63856     } catch (Dali::DaliException e) {
63857       {
63858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63859       };
63860     } catch (...) {
63861       {
63862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63863       };
63864     }
63865   }
63866
63867   jresult = result;
63868   return jresult;
63869 }
63870
63871
63872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63874
63875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63876   {
63877     try {
63878       (arg1)->ClearKeyInputFocus();
63879     } catch (std::out_of_range& e) {
63880       {
63881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63882       };
63883     } catch (std::exception& e) {
63884       {
63885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63886       };
63887     } catch (Dali::DaliException e) {
63888       {
63889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63890       };
63891     } catch (...) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63894       };
63895     }
63896   }
63897
63898 }
63899
63900
63901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63903   bool arg2 ;
63904
63905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63906   arg2 = jarg2 ? true : false;
63907   {
63908     try {
63909       (arg1)->SetAsKeyboardFocusGroup(arg2);
63910     } catch (std::out_of_range& e) {
63911       {
63912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63913       };
63914     } catch (std::exception& e) {
63915       {
63916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63917       };
63918     } catch (Dali::DaliException e) {
63919       {
63920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63921       };
63922     } catch (...) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63925       };
63926     }
63927   }
63928
63929 }
63930
63931
63932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63933   unsigned int jresult ;
63934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63935   bool result;
63936
63937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63938   {
63939     try {
63940       result = (bool)(arg1)->IsKeyboardFocusGroup();
63941     } catch (std::out_of_range& e) {
63942       {
63943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63944       };
63945     } catch (std::exception& e) {
63946       {
63947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63948       };
63949     } catch (Dali::DaliException e) {
63950       {
63951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63952       };
63953     } catch (...) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63956       };
63957     }
63958   }
63959
63960   jresult = result;
63961   return jresult;
63962 }
63963
63964
63965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
63966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63967
63968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63969   {
63970     try {
63971       (arg1)->AccessibilityActivate();
63972     } catch (std::out_of_range& e) {
63973       {
63974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63975       };
63976     } catch (std::exception& e) {
63977       {
63978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (Dali::DaliException e) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63987       };
63988     }
63989   }
63990
63991 }
63992
63993
63994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
63995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63996
63997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63998   {
63999     try {
64000       (arg1)->KeyboardEnter();
64001     } catch (std::out_of_range& e) {
64002       {
64003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64004       };
64005     } catch (std::exception& e) {
64006       {
64007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (Dali::DaliException e) {
64010       {
64011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64016       };
64017     }
64018   }
64019
64020 }
64021
64022
64023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64024   void * jresult ;
64025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64026   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64027
64028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64029   {
64030     try {
64031       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64032     } catch (std::out_of_range& e) {
64033       {
64034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64035       };
64036     } catch (std::exception& e) {
64037       {
64038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64039       };
64040     } catch (Dali::DaliException e) {
64041       {
64042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64043       };
64044     } catch (...) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64047       };
64048     }
64049   }
64050
64051   jresult = (void *)result;
64052   return jresult;
64053 }
64054
64055
64056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64057   void * jresult ;
64058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64059   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64060
64061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64062   {
64063     try {
64064       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64065     } catch (std::out_of_range& e) {
64066       {
64067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64068       };
64069     } catch (std::exception& e) {
64070       {
64071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64072       };
64073     } catch (Dali::DaliException e) {
64074       {
64075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64076       };
64077     } catch (...) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64080       };
64081     }
64082   }
64083
64084   jresult = (void *)result;
64085   return jresult;
64086 }
64087
64088
64089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64090   void * jresult ;
64091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64092   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64093
64094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64095   {
64096     try {
64097       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64098     } catch (std::out_of_range& e) {
64099       {
64100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64101       };
64102     } catch (std::exception& e) {
64103       {
64104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64105       };
64106     } catch (Dali::DaliException e) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64109       };
64110     } catch (...) {
64111       {
64112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64113       };
64114     }
64115   }
64116
64117   jresult = (void *)result;
64118   return jresult;
64119 }
64120
64121
64122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64123   unsigned int jresult ;
64124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64125   Dali::KeyEvent *arg2 = 0 ;
64126   bool result;
64127
64128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64129   arg2 = (Dali::KeyEvent *)jarg2;
64130   if (!arg2) {
64131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64132     return 0;
64133   }
64134   {
64135     try {
64136       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64137     } catch (std::out_of_range& e) {
64138       {
64139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64140       };
64141     } catch (std::exception& e) {
64142       {
64143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64144       };
64145     } catch (Dali::DaliException e) {
64146       {
64147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64148       };
64149     } catch (...) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64152       };
64153     }
64154   }
64155
64156   jresult = result;
64157   return jresult;
64158 }
64159
64160
64161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64163   int arg2 ;
64164   SwigDirector_ViewImpl *darg = 0;
64165
64166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64167   arg2 = (int)jarg2;
64168   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64169   {
64170     try {
64171       (darg)->OnStageConnection(arg2);
64172     } catch (std::out_of_range& e) {
64173       {
64174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64175       };
64176     } catch (std::exception& e) {
64177       {
64178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64179       };
64180     } catch (Dali::DaliException e) {
64181       {
64182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64183       };
64184     } catch (...) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64187       };
64188     }
64189   }
64190
64191 }
64192
64193
64194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64196   int arg2 ;
64197   SwigDirector_ViewImpl *darg = 0;
64198
64199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64200   arg2 = (int)jarg2;
64201   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64202   {
64203     try {
64204       (darg)->OnStageConnectionSwigPublic(arg2);
64205     } catch (std::out_of_range& e) {
64206       {
64207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64208       };
64209     } catch (std::exception& e) {
64210       {
64211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64212       };
64213     } catch (Dali::DaliException e) {
64214       {
64215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64216       };
64217     } catch (...) {
64218       {
64219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64220       };
64221     }
64222   }
64223
64224 }
64225
64226
64227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64229   SwigDirector_ViewImpl *darg = 0;
64230
64231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64232   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64233   {
64234     try {
64235       (darg)->OnStageDisconnection();
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64243       };
64244     } catch (Dali::DaliException e) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64247       };
64248     } catch (...) {
64249       {
64250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64251       };
64252     }
64253   }
64254
64255 }
64256
64257
64258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64260   SwigDirector_ViewImpl *darg = 0;
64261
64262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64263   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64264   {
64265     try {
64266       (darg)->OnStageDisconnectionSwigPublic();
64267     } catch (std::out_of_range& e) {
64268       {
64269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64270       };
64271     } catch (std::exception& e) {
64272       {
64273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64274       };
64275     } catch (Dali::DaliException e) {
64276       {
64277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64278       };
64279     } catch (...) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64282       };
64283     }
64284   }
64285
64286 }
64287
64288
64289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64291   Dali::Actor *arg2 = 0 ;
64292   SwigDirector_ViewImpl *darg = 0;
64293
64294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64295   arg2 = (Dali::Actor *)jarg2;
64296   if (!arg2) {
64297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64298     return ;
64299   }
64300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64301   {
64302     try {
64303       (darg)->OnChildAdd(*arg2);
64304     } catch (std::out_of_range& e) {
64305       {
64306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64307       };
64308     } catch (std::exception& e) {
64309       {
64310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64311       };
64312     } catch (Dali::DaliException e) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64315       };
64316     } catch (...) {
64317       {
64318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64319       };
64320     }
64321   }
64322
64323 }
64324
64325
64326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64328   Dali::Actor *arg2 = 0 ;
64329   SwigDirector_ViewImpl *darg = 0;
64330
64331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64332   arg2 = (Dali::Actor *)jarg2;
64333   if (!arg2) {
64334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64335     return ;
64336   }
64337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64338   {
64339     try {
64340       (darg)->OnChildAddSwigPublic(*arg2);
64341     } catch (std::out_of_range& e) {
64342       {
64343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64344       };
64345     } catch (std::exception& e) {
64346       {
64347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64348       };
64349     } catch (Dali::DaliException e) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64352       };
64353     } catch (...) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64356       };
64357     }
64358   }
64359
64360 }
64361
64362
64363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64365   Dali::Actor *arg2 = 0 ;
64366   SwigDirector_ViewImpl *darg = 0;
64367
64368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64369   arg2 = (Dali::Actor *)jarg2;
64370   if (!arg2) {
64371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64372     return ;
64373   }
64374   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64375   {
64376     try {
64377       (darg)->OnChildRemove(*arg2);
64378     } catch (std::out_of_range& e) {
64379       {
64380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64381       };
64382     } catch (std::exception& e) {
64383       {
64384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64385       };
64386     } catch (Dali::DaliException e) {
64387       {
64388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64389       };
64390     } catch (...) {
64391       {
64392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64393       };
64394     }
64395   }
64396
64397 }
64398
64399
64400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64402   Dali::Actor *arg2 = 0 ;
64403   SwigDirector_ViewImpl *darg = 0;
64404
64405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64406   arg2 = (Dali::Actor *)jarg2;
64407   if (!arg2) {
64408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64409     return ;
64410   }
64411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64412   {
64413     try {
64414       (darg)->OnChildRemoveSwigPublic(*arg2);
64415     } catch (std::out_of_range& e) {
64416       {
64417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64418       };
64419     } catch (std::exception& e) {
64420       {
64421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64422       };
64423     } catch (Dali::DaliException e) {
64424       {
64425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64426       };
64427     } catch (...) {
64428       {
64429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64430       };
64431     }
64432   }
64433
64434 }
64435
64436
64437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64439   Dali::Property::Index arg2 ;
64440   Dali::Property::Value arg3 ;
64441   Dali::Property::Value *argp3 ;
64442   SwigDirector_ViewImpl *darg = 0;
64443
64444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64445   arg2 = (Dali::Property::Index)jarg2;
64446   argp3 = (Dali::Property::Value *)jarg3;
64447   if (!argp3) {
64448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64449     return ;
64450   }
64451   arg3 = *argp3;
64452   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64453   {
64454     try {
64455       (darg)->OnPropertySet(arg2,arg3);
64456     } catch (std::out_of_range& e) {
64457       {
64458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64459       };
64460     } catch (std::exception& e) {
64461       {
64462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64463       };
64464     } catch (Dali::DaliException e) {
64465       {
64466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64467       };
64468     } catch (...) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64471       };
64472     }
64473   }
64474
64475 }
64476
64477
64478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64480   Dali::Property::Index arg2 ;
64481   Dali::Property::Value arg3 ;
64482   Dali::Property::Value *argp3 ;
64483   SwigDirector_ViewImpl *darg = 0;
64484
64485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64486   arg2 = (Dali::Property::Index)jarg2;
64487   argp3 = (Dali::Property::Value *)jarg3;
64488   if (!argp3) {
64489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64490     return ;
64491   }
64492   arg3 = *argp3;
64493   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64494   {
64495     try {
64496       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64497     } catch (std::out_of_range& e) {
64498       {
64499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64500       };
64501     } catch (std::exception& e) {
64502       {
64503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64504       };
64505     } catch (Dali::DaliException e) {
64506       {
64507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64508       };
64509     } catch (...) {
64510       {
64511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64512       };
64513     }
64514   }
64515
64516 }
64517
64518
64519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64520   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64521   Dali::Vector3 *arg2 = 0 ;
64522   SwigDirector_ViewImpl *darg = 0;
64523
64524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64525   arg2 = (Dali::Vector3 *)jarg2;
64526   if (!arg2) {
64527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64528     return ;
64529   }
64530   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64531   {
64532     try {
64533       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64534     } catch (std::out_of_range& e) {
64535       {
64536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64537       };
64538     } catch (std::exception& e) {
64539       {
64540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64541       };
64542     } catch (Dali::DaliException e) {
64543       {
64544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64545       };
64546     } catch (...) {
64547       {
64548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64549       };
64550     }
64551   }
64552
64553 }
64554
64555
64556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64558   Dali::Vector3 *arg2 = 0 ;
64559   SwigDirector_ViewImpl *darg = 0;
64560
64561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64562   arg2 = (Dali::Vector3 *)jarg2;
64563   if (!arg2) {
64564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64565     return ;
64566   }
64567   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64568   {
64569     try {
64570       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64571     } catch (std::out_of_range& e) {
64572       {
64573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64574       };
64575     } catch (std::exception& e) {
64576       {
64577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64578       };
64579     } catch (Dali::DaliException e) {
64580       {
64581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64582       };
64583     } catch (...) {
64584       {
64585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64586       };
64587     }
64588   }
64589
64590 }
64591
64592
64593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64594   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64595   Dali::Animation *arg2 = 0 ;
64596   Dali::Vector3 *arg3 = 0 ;
64597   SwigDirector_ViewImpl *darg = 0;
64598
64599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64600   arg2 = (Dali::Animation *)jarg2;
64601   if (!arg2) {
64602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64603     return ;
64604   }
64605   arg3 = (Dali::Vector3 *)jarg3;
64606   if (!arg3) {
64607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64608     return ;
64609   }
64610   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64611   {
64612     try {
64613       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64614     } catch (std::out_of_range& e) {
64615       {
64616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64617       };
64618     } catch (std::exception& e) {
64619       {
64620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64621       };
64622     } catch (Dali::DaliException e) {
64623       {
64624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64625       };
64626     } catch (...) {
64627       {
64628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64629       };
64630     }
64631   }
64632
64633 }
64634
64635
64636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64638   Dali::Animation *arg2 = 0 ;
64639   Dali::Vector3 *arg3 = 0 ;
64640   SwigDirector_ViewImpl *darg = 0;
64641
64642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64643   arg2 = (Dali::Animation *)jarg2;
64644   if (!arg2) {
64645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64646     return ;
64647   }
64648   arg3 = (Dali::Vector3 *)jarg3;
64649   if (!arg3) {
64650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64651     return ;
64652   }
64653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64654   {
64655     try {
64656       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64657     } catch (std::out_of_range& e) {
64658       {
64659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64660       };
64661     } catch (std::exception& e) {
64662       {
64663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64664       };
64665     } catch (Dali::DaliException e) {
64666       {
64667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64668       };
64669     } catch (...) {
64670       {
64671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64672       };
64673     }
64674   }
64675
64676 }
64677
64678
64679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64680   unsigned int jresult ;
64681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64682   Dali::TouchEvent *arg2 = 0 ;
64683   SwigDirector_ViewImpl *darg = 0;
64684   bool result;
64685
64686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64687   arg2 = (Dali::TouchEvent *)jarg2;
64688   if (!arg2) {
64689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64690     return 0;
64691   }
64692   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64693   {
64694     try {
64695       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64696     } catch (std::out_of_range& e) {
64697       {
64698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64699       };
64700     } catch (std::exception& e) {
64701       {
64702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64703       };
64704     } catch (Dali::DaliException e) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64707       };
64708     } catch (...) {
64709       {
64710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64711       };
64712     }
64713   }
64714
64715   jresult = result;
64716   return jresult;
64717 }
64718
64719
64720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64721   unsigned int jresult ;
64722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64723   Dali::TouchEvent *arg2 = 0 ;
64724   SwigDirector_ViewImpl *darg = 0;
64725   bool result;
64726
64727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64728   arg2 = (Dali::TouchEvent *)jarg2;
64729   if (!arg2) {
64730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64731     return 0;
64732   }
64733   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64734   {
64735     try {
64736       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64737     } catch (std::out_of_range& e) {
64738       {
64739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64740       };
64741     } catch (std::exception& e) {
64742       {
64743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64744       };
64745     } catch (Dali::DaliException e) {
64746       {
64747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64748       };
64749     } catch (...) {
64750       {
64751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64752       };
64753     }
64754   }
64755
64756   jresult = result;
64757   return jresult;
64758 }
64759
64760
64761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64762   unsigned int jresult ;
64763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64764   Dali::HoverEvent *arg2 = 0 ;
64765   SwigDirector_ViewImpl *darg = 0;
64766   bool result;
64767
64768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64769   arg2 = (Dali::HoverEvent *)jarg2;
64770   if (!arg2) {
64771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64772     return 0;
64773   }
64774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64775   {
64776     try {
64777       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64778     } catch (std::out_of_range& e) {
64779       {
64780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64781       };
64782     } catch (std::exception& e) {
64783       {
64784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64785       };
64786     } catch (Dali::DaliException e) {
64787       {
64788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64789       };
64790     } catch (...) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64793       };
64794     }
64795   }
64796
64797   jresult = result;
64798   return jresult;
64799 }
64800
64801
64802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64803   unsigned int jresult ;
64804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64805   Dali::HoverEvent *arg2 = 0 ;
64806   SwigDirector_ViewImpl *darg = 0;
64807   bool result;
64808
64809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64810   arg2 = (Dali::HoverEvent *)jarg2;
64811   if (!arg2) {
64812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64813     return 0;
64814   }
64815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64816   {
64817     try {
64818       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64819     } catch (std::out_of_range& e) {
64820       {
64821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64822       };
64823     } catch (std::exception& e) {
64824       {
64825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64826       };
64827     } catch (Dali::DaliException e) {
64828       {
64829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64830       };
64831     } catch (...) {
64832       {
64833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64834       };
64835     }
64836   }
64837
64838   jresult = result;
64839   return jresult;
64840 }
64841
64842
64843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64844   unsigned int jresult ;
64845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64846   Dali::KeyEvent *arg2 = 0 ;
64847   SwigDirector_ViewImpl *darg = 0;
64848   bool result;
64849
64850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64851   arg2 = (Dali::KeyEvent *)jarg2;
64852   if (!arg2) {
64853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64854     return 0;
64855   }
64856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64857   {
64858     try {
64859       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64860     } catch (std::out_of_range& e) {
64861       {
64862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64863       };
64864     } catch (std::exception& e) {
64865       {
64866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64867       };
64868     } catch (Dali::DaliException e) {
64869       {
64870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64871       };
64872     } catch (...) {
64873       {
64874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64875       };
64876     }
64877   }
64878
64879   jresult = result;
64880   return jresult;
64881 }
64882
64883
64884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64885   unsigned int jresult ;
64886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64887   Dali::KeyEvent *arg2 = 0 ;
64888   SwigDirector_ViewImpl *darg = 0;
64889   bool result;
64890
64891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64892   arg2 = (Dali::KeyEvent *)jarg2;
64893   if (!arg2) {
64894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64895     return 0;
64896   }
64897   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64898   {
64899     try {
64900       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64901     } catch (std::out_of_range& e) {
64902       {
64903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64904       };
64905     } catch (std::exception& e) {
64906       {
64907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64908       };
64909     } catch (Dali::DaliException e) {
64910       {
64911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64912       };
64913     } catch (...) {
64914       {
64915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64916       };
64917     }
64918   }
64919
64920   jresult = result;
64921   return jresult;
64922 }
64923
64924
64925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64926   unsigned int jresult ;
64927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64928   Dali::WheelEvent *arg2 = 0 ;
64929   SwigDirector_ViewImpl *darg = 0;
64930   bool result;
64931
64932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64933   arg2 = (Dali::WheelEvent *)jarg2;
64934   if (!arg2) {
64935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64936     return 0;
64937   }
64938   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64939   {
64940     try {
64941       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64942     } catch (std::out_of_range& e) {
64943       {
64944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64945       };
64946     } catch (std::exception& e) {
64947       {
64948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64949       };
64950     } catch (Dali::DaliException e) {
64951       {
64952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64953       };
64954     } catch (...) {
64955       {
64956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64957       };
64958     }
64959   }
64960
64961   jresult = result;
64962   return jresult;
64963 }
64964
64965
64966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64967   unsigned int jresult ;
64968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64969   Dali::WheelEvent *arg2 = 0 ;
64970   SwigDirector_ViewImpl *darg = 0;
64971   bool result;
64972
64973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64974   arg2 = (Dali::WheelEvent *)jarg2;
64975   if (!arg2) {
64976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64977     return 0;
64978   }
64979   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64980   {
64981     try {
64982       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64983     } catch (std::out_of_range& e) {
64984       {
64985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64986       };
64987     } catch (std::exception& e) {
64988       {
64989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (Dali::DaliException e) {
64992       {
64993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64994       };
64995     } catch (...) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64998       };
64999     }
65000   }
65001
65002   jresult = result;
65003   return jresult;
65004 }
65005
65006
65007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65009   Dali::Vector2 *arg2 = 0 ;
65010   Dali::RelayoutContainer *arg3 = 0 ;
65011   SwigDirector_ViewImpl *darg = 0;
65012
65013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65014   arg2 = (Dali::Vector2 *)jarg2;
65015   if (!arg2) {
65016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65017     return ;
65018   }
65019   arg3 = (Dali::RelayoutContainer *)jarg3;
65020   if (!arg3) {
65021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65022     return ;
65023   }
65024   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65025   {
65026     try {
65027       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65028     } catch (std::out_of_range& e) {
65029       {
65030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65031       };
65032     } catch (std::exception& e) {
65033       {
65034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65035       };
65036     } catch (Dali::DaliException e) {
65037       {
65038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65039       };
65040     } catch (...) {
65041       {
65042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65043       };
65044     }
65045   }
65046
65047 }
65048
65049
65050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65052   Dali::Vector2 *arg2 = 0 ;
65053   Dali::RelayoutContainer *arg3 = 0 ;
65054   SwigDirector_ViewImpl *darg = 0;
65055
65056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65057   arg2 = (Dali::Vector2 *)jarg2;
65058   if (!arg2) {
65059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65060     return ;
65061   }
65062   arg3 = (Dali::RelayoutContainer *)jarg3;
65063   if (!arg3) {
65064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65065     return ;
65066   }
65067   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65068   {
65069     try {
65070       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65071     } catch (std::out_of_range& e) {
65072       {
65073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65074       };
65075     } catch (std::exception& e) {
65076       {
65077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65078       };
65079     } catch (Dali::DaliException e) {
65080       {
65081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65082       };
65083     } catch (...) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65086       };
65087     }
65088   }
65089
65090 }
65091
65092
65093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65095   Dali::ResizePolicy::Type arg2 ;
65096   Dali::Dimension::Type arg3 ;
65097   SwigDirector_ViewImpl *darg = 0;
65098
65099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65100   arg2 = (Dali::ResizePolicy::Type)jarg2;
65101   arg3 = (Dali::Dimension::Type)jarg3;
65102   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65103   {
65104     try {
65105       (darg)->OnSetResizePolicy(arg2,arg3);
65106     } catch (std::out_of_range& e) {
65107       {
65108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65109       };
65110     } catch (std::exception& e) {
65111       {
65112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65113       };
65114     } catch (Dali::DaliException e) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65121       };
65122     }
65123   }
65124
65125 }
65126
65127
65128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65130   Dali::ResizePolicy::Type arg2 ;
65131   Dali::Dimension::Type arg3 ;
65132   SwigDirector_ViewImpl *darg = 0;
65133
65134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65135   arg2 = (Dali::ResizePolicy::Type)jarg2;
65136   arg3 = (Dali::Dimension::Type)jarg3;
65137   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65138   {
65139     try {
65140       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65141     } catch (std::out_of_range& e) {
65142       {
65143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65144       };
65145     } catch (std::exception& e) {
65146       {
65147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65148       };
65149     } catch (Dali::DaliException e) {
65150       {
65151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65152       };
65153     } catch (...) {
65154       {
65155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65156       };
65157     }
65158   }
65159
65160 }
65161
65162
65163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65164   void * jresult ;
65165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65166   SwigDirector_ViewImpl *darg = 0;
65167   Dali::Vector3 result;
65168
65169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65171   {
65172     try {
65173       result = (darg)->GetNaturalSize();
65174     } catch (std::out_of_range& e) {
65175       {
65176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65177       };
65178     } catch (std::exception& e) {
65179       {
65180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (Dali::DaliException e) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65185       };
65186     } catch (...) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65189       };
65190     }
65191   }
65192
65193   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65194   return jresult;
65195 }
65196
65197
65198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65199   void * jresult ;
65200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65201   SwigDirector_ViewImpl *darg = 0;
65202   Dali::Vector3 result;
65203
65204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65206   {
65207     try {
65208       result = (darg)->GetNaturalSizeSwigPublic();
65209     } catch (std::out_of_range& e) {
65210       {
65211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65212       };
65213     } catch (std::exception& e) {
65214       {
65215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65216       };
65217     } catch (Dali::DaliException e) {
65218       {
65219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65220       };
65221     } catch (...) {
65222       {
65223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65224       };
65225     }
65226   }
65227
65228   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65229   return jresult;
65230 }
65231
65232
65233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65234   float jresult ;
65235   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65236   Dali::Actor *arg2 = 0 ;
65237   Dali::Dimension::Type arg3 ;
65238   SwigDirector_ViewImpl *darg = 0;
65239   float result;
65240
65241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65242   arg2 = (Dali::Actor *)jarg2;
65243   if (!arg2) {
65244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65245     return 0;
65246   }
65247   arg3 = (Dali::Dimension::Type)jarg3;
65248   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65249   {
65250     try {
65251       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65252     } catch (std::out_of_range& e) {
65253       {
65254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65255       };
65256     } catch (std::exception& e) {
65257       {
65258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (Dali::DaliException e) {
65261       {
65262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65263       };
65264     } catch (...) {
65265       {
65266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65267       };
65268     }
65269   }
65270
65271   jresult = result;
65272   return jresult;
65273 }
65274
65275
65276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65277   float jresult ;
65278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65279   Dali::Actor *arg2 = 0 ;
65280   Dali::Dimension::Type arg3 ;
65281   SwigDirector_ViewImpl *darg = 0;
65282   float result;
65283
65284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65285   arg2 = (Dali::Actor *)jarg2;
65286   if (!arg2) {
65287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65288     return 0;
65289   }
65290   arg3 = (Dali::Dimension::Type)jarg3;
65291   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65292   {
65293     try {
65294       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65295     } catch (std::out_of_range& e) {
65296       {
65297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65298       };
65299     } catch (std::exception& e) {
65300       {
65301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (Dali::DaliException e) {
65304       {
65305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65306       };
65307     } catch (...) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65310       };
65311     }
65312   }
65313
65314   jresult = result;
65315   return jresult;
65316 }
65317
65318
65319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65320   float jresult ;
65321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65322   float arg2 ;
65323   SwigDirector_ViewImpl *darg = 0;
65324   float result;
65325
65326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65327   arg2 = (float)jarg2;
65328   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65329   {
65330     try {
65331       result = (float)(darg)->GetHeightForWidth(arg2);
65332     } catch (std::out_of_range& e) {
65333       {
65334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65335       };
65336     } catch (std::exception& e) {
65337       {
65338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65339       };
65340     } catch (Dali::DaliException e) {
65341       {
65342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65343       };
65344     } catch (...) {
65345       {
65346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65347       };
65348     }
65349   }
65350
65351   jresult = result;
65352   return jresult;
65353 }
65354
65355
65356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65357   float jresult ;
65358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65359   float arg2 ;
65360   SwigDirector_ViewImpl *darg = 0;
65361   float result;
65362
65363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65364   arg2 = (float)jarg2;
65365   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65366   {
65367     try {
65368       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65369     } catch (std::out_of_range& e) {
65370       {
65371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65372       };
65373     } catch (std::exception& e) {
65374       {
65375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65376       };
65377     } catch (Dali::DaliException e) {
65378       {
65379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65380       };
65381     } catch (...) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65384       };
65385     }
65386   }
65387
65388   jresult = result;
65389   return jresult;
65390 }
65391
65392
65393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65394   float jresult ;
65395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65396   float arg2 ;
65397   SwigDirector_ViewImpl *darg = 0;
65398   float result;
65399
65400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65401   arg2 = (float)jarg2;
65402   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65403   {
65404     try {
65405       result = (float)(darg)->GetWidthForHeight(arg2);
65406     } catch (std::out_of_range& e) {
65407       {
65408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65409       };
65410     } catch (std::exception& e) {
65411       {
65412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65413       };
65414     } catch (Dali::DaliException e) {
65415       {
65416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65417       };
65418     } catch (...) {
65419       {
65420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65421       };
65422     }
65423   }
65424
65425   jresult = result;
65426   return jresult;
65427 }
65428
65429
65430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65431   float jresult ;
65432   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65433   float arg2 ;
65434   SwigDirector_ViewImpl *darg = 0;
65435   float result;
65436
65437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65438   arg2 = (float)jarg2;
65439   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65440   {
65441     try {
65442       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65443     } catch (std::out_of_range& e) {
65444       {
65445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65446       };
65447     } catch (std::exception& e) {
65448       {
65449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65450       };
65451     } catch (Dali::DaliException e) {
65452       {
65453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65454       };
65455     } catch (...) {
65456       {
65457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65458       };
65459     }
65460   }
65461
65462   jresult = result;
65463   return jresult;
65464 }
65465
65466
65467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65468   unsigned int jresult ;
65469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65470   Dali::Dimension::Type arg2 ;
65471   SwigDirector_ViewImpl *darg = 0;
65472   bool result;
65473
65474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65475   arg2 = (Dali::Dimension::Type)jarg2;
65476   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65477   {
65478     try {
65479       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65480     } catch (std::out_of_range& e) {
65481       {
65482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65483       };
65484     } catch (std::exception& e) {
65485       {
65486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65487       };
65488     } catch (Dali::DaliException e) {
65489       {
65490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65491       };
65492     } catch (...) {
65493       {
65494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65495       };
65496     }
65497   }
65498
65499   jresult = result;
65500   return jresult;
65501 }
65502
65503
65504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65505   unsigned int jresult ;
65506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65507   Dali::Dimension::Type arg2 ;
65508   SwigDirector_ViewImpl *darg = 0;
65509   bool result;
65510
65511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65512   arg2 = (Dali::Dimension::Type)jarg2;
65513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65514   {
65515     try {
65516       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65517     } catch (std::out_of_range& e) {
65518       {
65519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (std::exception& e) {
65522       {
65523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65524       };
65525     } catch (Dali::DaliException e) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65528       };
65529     } catch (...) {
65530       {
65531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65532       };
65533     }
65534   }
65535
65536   jresult = result;
65537   return jresult;
65538 }
65539
65540
65541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65542   unsigned int jresult ;
65543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65544   SwigDirector_ViewImpl *darg = 0;
65545   bool result;
65546
65547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65548   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65549   {
65550     try {
65551       result = (bool)(darg)->RelayoutDependentOnChildren();
65552     } catch (std::out_of_range& e) {
65553       {
65554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65555       };
65556     } catch (std::exception& e) {
65557       {
65558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65559       };
65560     } catch (Dali::DaliException e) {
65561       {
65562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65563       };
65564     } catch (...) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65567       };
65568     }
65569   }
65570
65571   jresult = result;
65572   return jresult;
65573 }
65574
65575
65576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65577   unsigned int jresult ;
65578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65579   SwigDirector_ViewImpl *darg = 0;
65580   bool result;
65581
65582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65583   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65584   {
65585     try {
65586       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65587     } catch (std::out_of_range& e) {
65588       {
65589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65590       };
65591     } catch (std::exception& e) {
65592       {
65593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65594       };
65595     } catch (Dali::DaliException e) {
65596       {
65597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65598       };
65599     } catch (...) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65602       };
65603     }
65604   }
65605
65606   jresult = result;
65607   return jresult;
65608 }
65609
65610
65611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65613   Dali::Dimension::Type arg2 ;
65614   SwigDirector_ViewImpl *darg = 0;
65615
65616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65617   arg2 = (Dali::Dimension::Type)jarg2;
65618   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65619   {
65620     try {
65621       (darg)->OnCalculateRelayoutSize(arg2);
65622     } catch (std::out_of_range& e) {
65623       {
65624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65625       };
65626     } catch (std::exception& e) {
65627       {
65628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65629       };
65630     } catch (Dali::DaliException e) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65633       };
65634     } catch (...) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65637       };
65638     }
65639   }
65640
65641 }
65642
65643
65644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65646   Dali::Dimension::Type arg2 ;
65647   SwigDirector_ViewImpl *darg = 0;
65648
65649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65650   arg2 = (Dali::Dimension::Type)jarg2;
65651   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65652   {
65653     try {
65654       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (Dali::DaliException e) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65670       };
65671     }
65672   }
65673
65674 }
65675
65676
65677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65679   float arg2 ;
65680   Dali::Dimension::Type arg3 ;
65681   SwigDirector_ViewImpl *darg = 0;
65682
65683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65684   arg2 = (float)jarg2;
65685   arg3 = (Dali::Dimension::Type)jarg3;
65686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65687   {
65688     try {
65689       (darg)->OnLayoutNegotiated(arg2,arg3);
65690     } catch (std::out_of_range& e) {
65691       {
65692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65693       };
65694     } catch (std::exception& e) {
65695       {
65696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65697       };
65698     } catch (Dali::DaliException e) {
65699       {
65700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65701       };
65702     } catch (...) {
65703       {
65704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65705       };
65706     }
65707   }
65708
65709 }
65710
65711
65712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65714   float arg2 ;
65715   Dali::Dimension::Type arg3 ;
65716   SwigDirector_ViewImpl *darg = 0;
65717
65718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65719   arg2 = (float)jarg2;
65720   arg3 = (Dali::Dimension::Type)jarg3;
65721   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65722   {
65723     try {
65724       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65725     } catch (std::out_of_range& e) {
65726       {
65727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65728       };
65729     } catch (std::exception& e) {
65730       {
65731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65732       };
65733     } catch (Dali::DaliException e) {
65734       {
65735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65736       };
65737     } catch (...) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65740       };
65741     }
65742   }
65743
65744 }
65745
65746
65747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65749
65750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65751   {
65752     try {
65753       (arg1)->OnInitialize();
65754     } catch (std::out_of_range& e) {
65755       {
65756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65757       };
65758     } catch (std::exception& e) {
65759       {
65760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65761       };
65762     } catch (Dali::DaliException e) {
65763       {
65764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65765       };
65766     } catch (...) {
65767       {
65768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65769       };
65770     }
65771   }
65772
65773 }
65774
65775
65776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65778
65779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65780   {
65781     try {
65782       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65783     } catch (std::out_of_range& e) {
65784       {
65785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65786       };
65787     } catch (std::exception& e) {
65788       {
65789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65790       };
65791     } catch (Dali::DaliException e) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65794       };
65795     } catch (...) {
65796       {
65797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65798       };
65799     }
65800   }
65801
65802 }
65803
65804
65805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65807   Dali::Actor *arg2 = 0 ;
65808
65809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65810   arg2 = (Dali::Actor *)jarg2;
65811   if (!arg2) {
65812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65813     return ;
65814   }
65815   {
65816     try {
65817       (arg1)->OnControlChildAdd(*arg2);
65818     } catch (std::out_of_range& e) {
65819       {
65820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65821       };
65822     } catch (std::exception& e) {
65823       {
65824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65825       };
65826     } catch (Dali::DaliException e) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65829       };
65830     } catch (...) {
65831       {
65832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65833       };
65834     }
65835   }
65836
65837 }
65838
65839
65840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65842   Dali::Actor *arg2 = 0 ;
65843
65844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65845   arg2 = (Dali::Actor *)jarg2;
65846   if (!arg2) {
65847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65848     return ;
65849   }
65850   {
65851     try {
65852       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65853     } catch (std::out_of_range& e) {
65854       {
65855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65856       };
65857     } catch (std::exception& e) {
65858       {
65859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65860       };
65861     } catch (Dali::DaliException e) {
65862       {
65863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65864       };
65865     } catch (...) {
65866       {
65867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65868       };
65869     }
65870   }
65871
65872 }
65873
65874
65875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65877   Dali::Actor *arg2 = 0 ;
65878
65879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65880   arg2 = (Dali::Actor *)jarg2;
65881   if (!arg2) {
65882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65883     return ;
65884   }
65885   {
65886     try {
65887       (arg1)->OnControlChildRemove(*arg2);
65888     } catch (std::out_of_range& e) {
65889       {
65890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65891       };
65892     } catch (std::exception& e) {
65893       {
65894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65895       };
65896     } catch (Dali::DaliException e) {
65897       {
65898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65899       };
65900     } catch (...) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65903       };
65904     }
65905   }
65906
65907 }
65908
65909
65910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65912   Dali::Actor *arg2 = 0 ;
65913
65914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65915   arg2 = (Dali::Actor *)jarg2;
65916   if (!arg2) {
65917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65918     return ;
65919   }
65920   {
65921     try {
65922       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65923     } catch (std::out_of_range& e) {
65924       {
65925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65926       };
65927     } catch (std::exception& e) {
65928       {
65929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65930       };
65931     } catch (Dali::DaliException e) {
65932       {
65933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65934       };
65935     } catch (...) {
65936       {
65937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65938       };
65939     }
65940   }
65941
65942 }
65943
65944
65945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65947   Dali::Toolkit::StyleManager arg2 ;
65948   Dali::StyleChange::Type arg3 ;
65949   Dali::Toolkit::StyleManager *argp2 ;
65950
65951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65952   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65953   if (!argp2) {
65954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65955     return ;
65956   }
65957   arg2 = *argp2;
65958   arg3 = (Dali::StyleChange::Type)jarg3;
65959   {
65960     try {
65961       (arg1)->OnStyleChange(arg2,arg3);
65962     } catch (std::out_of_range& e) {
65963       {
65964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65965       };
65966     } catch (std::exception& e) {
65967       {
65968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65969       };
65970     } catch (Dali::DaliException e) {
65971       {
65972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65973       };
65974     } catch (...) {
65975       {
65976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65977       };
65978     }
65979   }
65980
65981 }
65982
65983
65984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65986   Dali::Toolkit::StyleManager arg2 ;
65987   Dali::StyleChange::Type arg3 ;
65988   Dali::Toolkit::StyleManager *argp2 ;
65989
65990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65991   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65992   if (!argp2) {
65993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65994     return ;
65995   }
65996   arg2 = *argp2;
65997   arg3 = (Dali::StyleChange::Type)jarg3;
65998   {
65999     try {
66000       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66001     } catch (std::out_of_range& e) {
66002       {
66003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66004       };
66005     } catch (std::exception& e) {
66006       {
66007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66008       };
66009     } catch (Dali::DaliException e) {
66010       {
66011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66012       };
66013     } catch (...) {
66014       {
66015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66016       };
66017     }
66018   }
66019
66020 }
66021
66022
66023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66024   unsigned int jresult ;
66025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66026   bool result;
66027
66028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66029   {
66030     try {
66031       result = (bool)(arg1)->OnAccessibilityActivated();
66032     } catch (std::out_of_range& e) {
66033       {
66034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66035       };
66036     } catch (std::exception& e) {
66037       {
66038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66039       };
66040     } catch (Dali::DaliException e) {
66041       {
66042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66043       };
66044     } catch (...) {
66045       {
66046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66047       };
66048     }
66049   }
66050
66051   jresult = result;
66052   return jresult;
66053 }
66054
66055
66056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66057   unsigned int jresult ;
66058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66059   bool result;
66060
66061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66062   {
66063     try {
66064       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66065     } catch (std::out_of_range& e) {
66066       {
66067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66068       };
66069     } catch (std::exception& e) {
66070       {
66071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66072       };
66073     } catch (Dali::DaliException e) {
66074       {
66075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66076       };
66077     } catch (...) {
66078       {
66079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66080       };
66081     }
66082   }
66083
66084   jresult = result;
66085   return jresult;
66086 }
66087
66088
66089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66090   unsigned int jresult ;
66091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66092   Dali::PanGesture arg2 ;
66093   Dali::PanGesture *argp2 ;
66094   bool result;
66095
66096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66097   argp2 = (Dali::PanGesture *)jarg2;
66098   if (!argp2) {
66099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66100     return 0;
66101   }
66102   arg2 = *argp2;
66103   {
66104     try {
66105       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66106     } catch (std::out_of_range& e) {
66107       {
66108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66109       };
66110     } catch (std::exception& e) {
66111       {
66112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66113       };
66114     } catch (Dali::DaliException e) {
66115       {
66116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66117       };
66118     } catch (...) {
66119       {
66120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66121       };
66122     }
66123   }
66124
66125   jresult = result;
66126   return jresult;
66127 }
66128
66129
66130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66131   unsigned int jresult ;
66132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66133   Dali::PanGesture arg2 ;
66134   Dali::PanGesture *argp2 ;
66135   bool result;
66136
66137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66138   argp2 = (Dali::PanGesture *)jarg2;
66139   if (!argp2) {
66140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66141     return 0;
66142   }
66143   arg2 = *argp2;
66144   {
66145     try {
66146       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66147     } catch (std::out_of_range& e) {
66148       {
66149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66150       };
66151     } catch (std::exception& e) {
66152       {
66153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66154       };
66155     } catch (Dali::DaliException e) {
66156       {
66157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66158       };
66159     } catch (...) {
66160       {
66161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66162       };
66163     }
66164   }
66165
66166   jresult = result;
66167   return jresult;
66168 }
66169
66170
66171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66172   unsigned int jresult ;
66173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66174   Dali::TouchEvent *arg2 = 0 ;
66175   bool result;
66176
66177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66178   arg2 = (Dali::TouchEvent *)jarg2;
66179   if (!arg2) {
66180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66181     return 0;
66182   }
66183   {
66184     try {
66185       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66186     } catch (std::out_of_range& e) {
66187       {
66188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66189       };
66190     } catch (std::exception& e) {
66191       {
66192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66193       };
66194     } catch (Dali::DaliException e) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66197       };
66198     } catch (...) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66201       };
66202     }
66203   }
66204
66205   jresult = result;
66206   return jresult;
66207 }
66208
66209
66210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66211   unsigned int jresult ;
66212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66213   Dali::TouchEvent *arg2 = 0 ;
66214   bool result;
66215
66216   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66217   arg2 = (Dali::TouchEvent *)jarg2;
66218   if (!arg2) {
66219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66220     return 0;
66221   }
66222   {
66223     try {
66224       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66225     } catch (std::out_of_range& e) {
66226       {
66227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66228       };
66229     } catch (std::exception& e) {
66230       {
66231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66232       };
66233     } catch (Dali::DaliException e) {
66234       {
66235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66236       };
66237     } catch (...) {
66238       {
66239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66240       };
66241     }
66242   }
66243
66244   jresult = result;
66245   return jresult;
66246 }
66247
66248
66249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66250   unsigned int jresult ;
66251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66252   bool arg2 ;
66253   bool result;
66254
66255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66256   arg2 = jarg2 ? true : false;
66257   {
66258     try {
66259       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66260     } catch (std::out_of_range& e) {
66261       {
66262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66263       };
66264     } catch (std::exception& e) {
66265       {
66266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66267       };
66268     } catch (Dali::DaliException e) {
66269       {
66270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66271       };
66272     } catch (...) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66275       };
66276     }
66277   }
66278
66279   jresult = result;
66280   return jresult;
66281 }
66282
66283
66284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66285   unsigned int jresult ;
66286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66287   bool arg2 ;
66288   bool result;
66289
66290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66291   arg2 = jarg2 ? true : false;
66292   {
66293     try {
66294       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66295     } catch (std::out_of_range& e) {
66296       {
66297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66298       };
66299     } catch (std::exception& e) {
66300       {
66301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66302       };
66303     } catch (Dali::DaliException e) {
66304       {
66305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66306       };
66307     } catch (...) {
66308       {
66309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66310       };
66311     }
66312   }
66313
66314   jresult = result;
66315   return jresult;
66316 }
66317
66318
66319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66320   unsigned int jresult ;
66321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66322   bool result;
66323
66324   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66325   {
66326     try {
66327       result = (bool)(arg1)->OnAccessibilityZoom();
66328     } catch (std::out_of_range& e) {
66329       {
66330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66331       };
66332     } catch (std::exception& e) {
66333       {
66334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66335       };
66336     } catch (Dali::DaliException e) {
66337       {
66338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66339       };
66340     } catch (...) {
66341       {
66342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66343       };
66344     }
66345   }
66346
66347   jresult = result;
66348   return jresult;
66349 }
66350
66351
66352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66353   unsigned int jresult ;
66354   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66355   bool result;
66356
66357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66358   {
66359     try {
66360       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66361     } catch (std::out_of_range& e) {
66362       {
66363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66364       };
66365     } catch (std::exception& e) {
66366       {
66367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66368       };
66369     } catch (Dali::DaliException e) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66372       };
66373     } catch (...) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66376       };
66377     }
66378   }
66379
66380   jresult = result;
66381   return jresult;
66382 }
66383
66384
66385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66387
66388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66389   {
66390     try {
66391       (arg1)->OnKeyInputFocusGained();
66392     } catch (std::out_of_range& e) {
66393       {
66394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66395       };
66396     } catch (std::exception& e) {
66397       {
66398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66399       };
66400     } catch (Dali::DaliException e) {
66401       {
66402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66403       };
66404     } catch (...) {
66405       {
66406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66407       };
66408     }
66409   }
66410
66411 }
66412
66413
66414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66416
66417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66418   {
66419     try {
66420       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66421     } catch (std::out_of_range& e) {
66422       {
66423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66424       };
66425     } catch (std::exception& e) {
66426       {
66427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66428       };
66429     } catch (Dali::DaliException e) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66432       };
66433     } catch (...) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66436       };
66437     }
66438   }
66439
66440 }
66441
66442
66443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66445
66446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66447   {
66448     try {
66449       (arg1)->OnKeyInputFocusLost();
66450     } catch (std::out_of_range& e) {
66451       {
66452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66453       };
66454     } catch (std::exception& e) {
66455       {
66456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66457       };
66458     } catch (Dali::DaliException e) {
66459       {
66460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66461       };
66462     } catch (...) {
66463       {
66464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66465       };
66466     }
66467   }
66468
66469 }
66470
66471
66472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66474
66475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66476   {
66477     try {
66478       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66479     } catch (std::out_of_range& e) {
66480       {
66481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66482       };
66483     } catch (std::exception& e) {
66484       {
66485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66486       };
66487     } catch (Dali::DaliException e) {
66488       {
66489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66490       };
66491     } catch (...) {
66492       {
66493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66494       };
66495     }
66496   }
66497
66498 }
66499
66500
66501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66502   void * jresult ;
66503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66504   Dali::Actor arg2 ;
66505   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66506   bool arg4 ;
66507   Dali::Actor *argp2 ;
66508   Dali::Actor result;
66509
66510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66511   argp2 = (Dali::Actor *)jarg2;
66512   if (!argp2) {
66513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66514     return 0;
66515   }
66516   arg2 = *argp2;
66517   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66518   arg4 = jarg4 ? true : false;
66519   {
66520     try {
66521       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66522     } catch (std::out_of_range& e) {
66523       {
66524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66525       };
66526     } catch (std::exception& e) {
66527       {
66528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66529       };
66530     } catch (Dali::DaliException e) {
66531       {
66532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66533       };
66534     } catch (...) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66537       };
66538     }
66539   }
66540
66541   jresult = new Dali::Actor((const Dali::Actor &)result);
66542   return jresult;
66543 }
66544
66545
66546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66547   void * jresult ;
66548   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66549   Dali::Actor arg2 ;
66550   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66551   bool arg4 ;
66552   Dali::Actor *argp2 ;
66553   Dali::Actor result;
66554
66555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66556   argp2 = (Dali::Actor *)jarg2;
66557   if (!argp2) {
66558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66559     return 0;
66560   }
66561   arg2 = *argp2;
66562   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66563   arg4 = jarg4 ? true : false;
66564   {
66565     try {
66566       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66567     } catch (std::out_of_range& e) {
66568       {
66569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66570       };
66571     } catch (std::exception& e) {
66572       {
66573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (Dali::DaliException e) {
66576       {
66577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66578       };
66579     } catch (...) {
66580       {
66581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66582       };
66583     }
66584   }
66585
66586   jresult = new Dali::Actor((const Dali::Actor &)result);
66587   return jresult;
66588 }
66589
66590
66591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66593   Dali::Actor arg2 ;
66594   Dali::Actor *argp2 ;
66595
66596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66597   argp2 = (Dali::Actor *)jarg2;
66598   if (!argp2) {
66599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66600     return ;
66601   }
66602   arg2 = *argp2;
66603   {
66604     try {
66605       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66613       };
66614     } catch (Dali::DaliException e) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66617       };
66618     } catch (...) {
66619       {
66620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66621       };
66622     }
66623   }
66624
66625 }
66626
66627
66628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66630   Dali::Actor arg2 ;
66631   Dali::Actor *argp2 ;
66632
66633   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66634   argp2 = (Dali::Actor *)jarg2;
66635   if (!argp2) {
66636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66637     return ;
66638   }
66639   arg2 = *argp2;
66640   {
66641     try {
66642       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66643     } catch (std::out_of_range& e) {
66644       {
66645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66646       };
66647     } catch (std::exception& e) {
66648       {
66649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66650       };
66651     } catch (Dali::DaliException e) {
66652       {
66653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66654       };
66655     } catch (...) {
66656       {
66657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66658       };
66659     }
66660   }
66661
66662 }
66663
66664
66665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66666   unsigned int jresult ;
66667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66668   bool result;
66669
66670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66671   {
66672     try {
66673       result = (bool)(arg1)->OnKeyboardEnter();
66674     } catch (std::out_of_range& e) {
66675       {
66676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66677       };
66678     } catch (std::exception& e) {
66679       {
66680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66681       };
66682     } catch (Dali::DaliException e) {
66683       {
66684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66685       };
66686     } catch (...) {
66687       {
66688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66689       };
66690     }
66691   }
66692
66693   jresult = result;
66694   return jresult;
66695 }
66696
66697
66698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66699   unsigned int jresult ;
66700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66701   bool result;
66702
66703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66704   {
66705     try {
66706       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66707     } catch (std::out_of_range& e) {
66708       {
66709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66710       };
66711     } catch (std::exception& e) {
66712       {
66713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (Dali::DaliException e) {
66716       {
66717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66718       };
66719     } catch (...) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66722       };
66723     }
66724   }
66725
66726   jresult = result;
66727   return jresult;
66728 }
66729
66730
66731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66733   Dali::PinchGesture *arg2 = 0 ;
66734
66735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66736   arg2 = (Dali::PinchGesture *)jarg2;
66737   if (!arg2) {
66738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66739     return ;
66740   }
66741   {
66742     try {
66743       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66744     } catch (std::out_of_range& e) {
66745       {
66746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66747       };
66748     } catch (std::exception& e) {
66749       {
66750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66751       };
66752     } catch (Dali::DaliException e) {
66753       {
66754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66755       };
66756     } catch (...) {
66757       {
66758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66759       };
66760     }
66761   }
66762
66763 }
66764
66765
66766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66768   Dali::PinchGesture *arg2 = 0 ;
66769
66770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66771   arg2 = (Dali::PinchGesture *)jarg2;
66772   if (!arg2) {
66773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66774     return ;
66775   }
66776   {
66777     try {
66778       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66779     } catch (std::out_of_range& e) {
66780       {
66781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66782       };
66783     } catch (std::exception& e) {
66784       {
66785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66786       };
66787     } catch (Dali::DaliException e) {
66788       {
66789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66790       };
66791     } catch (...) {
66792       {
66793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66794       };
66795     }
66796   }
66797
66798 }
66799
66800
66801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66803   Dali::PanGesture *arg2 = 0 ;
66804
66805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66806   arg2 = (Dali::PanGesture *)jarg2;
66807   if (!arg2) {
66808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66809     return ;
66810   }
66811   {
66812     try {
66813       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66814     } catch (std::out_of_range& e) {
66815       {
66816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66817       };
66818     } catch (std::exception& e) {
66819       {
66820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66821       };
66822     } catch (Dali::DaliException e) {
66823       {
66824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66825       };
66826     } catch (...) {
66827       {
66828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66829       };
66830     }
66831   }
66832
66833 }
66834
66835
66836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66838   Dali::PanGesture *arg2 = 0 ;
66839
66840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66841   arg2 = (Dali::PanGesture *)jarg2;
66842   if (!arg2) {
66843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66844     return ;
66845   }
66846   {
66847     try {
66848       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66849     } catch (std::out_of_range& e) {
66850       {
66851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66852       };
66853     } catch (std::exception& e) {
66854       {
66855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66856       };
66857     } catch (Dali::DaliException e) {
66858       {
66859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66860       };
66861     } catch (...) {
66862       {
66863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66864       };
66865     }
66866   }
66867
66868 }
66869
66870
66871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66873   Dali::TapGesture *arg2 = 0 ;
66874
66875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66876   arg2 = (Dali::TapGesture *)jarg2;
66877   if (!arg2) {
66878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66879     return ;
66880   }
66881   {
66882     try {
66883       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66884     } catch (std::out_of_range& e) {
66885       {
66886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66887       };
66888     } catch (std::exception& e) {
66889       {
66890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66891       };
66892     } catch (Dali::DaliException e) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66895       };
66896     } catch (...) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66899       };
66900     }
66901   }
66902
66903 }
66904
66905
66906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66908   Dali::TapGesture *arg2 = 0 ;
66909
66910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66911   arg2 = (Dali::TapGesture *)jarg2;
66912   if (!arg2) {
66913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66914     return ;
66915   }
66916   {
66917     try {
66918       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66919     } catch (std::out_of_range& e) {
66920       {
66921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66922       };
66923     } catch (std::exception& e) {
66924       {
66925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (Dali::DaliException e) {
66928       {
66929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66930       };
66931     } catch (...) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66934       };
66935     }
66936   }
66937
66938 }
66939
66940
66941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66943   Dali::LongPressGesture *arg2 = 0 ;
66944
66945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66946   arg2 = (Dali::LongPressGesture *)jarg2;
66947   if (!arg2) {
66948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66949     return ;
66950   }
66951   {
66952     try {
66953       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66954     } catch (std::out_of_range& e) {
66955       {
66956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66957       };
66958     } catch (std::exception& e) {
66959       {
66960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66961       };
66962     } catch (Dali::DaliException e) {
66963       {
66964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66965       };
66966     } catch (...) {
66967       {
66968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66969       };
66970     }
66971   }
66972
66973 }
66974
66975
66976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66978   Dali::LongPressGesture *arg2 = 0 ;
66979
66980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66981   arg2 = (Dali::LongPressGesture *)jarg2;
66982   if (!arg2) {
66983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66984     return ;
66985   }
66986   {
66987     try {
66988       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66989     } catch (std::out_of_range& e) {
66990       {
66991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66992       };
66993     } catch (std::exception& e) {
66994       {
66995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66996       };
66997     } catch (Dali::DaliException e) {
66998       {
66999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67000       };
67001     } catch (...) {
67002       {
67003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67004       };
67005     }
67006   }
67007
67008 }
67009
67010
67011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67013   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67014   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67015
67016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67017   arg2 = (Dali::SlotObserver *)jarg2;
67018   arg3 = (Dali::CallbackBase *)jarg3;
67019   {
67020     try {
67021       (arg1)->SignalConnected(arg2,arg3);
67022     } catch (std::out_of_range& e) {
67023       {
67024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67025       };
67026     } catch (std::exception& e) {
67027       {
67028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67029       };
67030     } catch (Dali::DaliException e) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67033       };
67034     } catch (...) {
67035       {
67036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67037       };
67038     }
67039   }
67040
67041 }
67042
67043
67044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67046   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67047   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67048
67049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67050   arg2 = (Dali::SlotObserver *)jarg2;
67051   arg3 = (Dali::CallbackBase *)jarg3;
67052   {
67053     try {
67054       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (Dali::DaliException e) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67070       };
67071     }
67072   }
67073
67074 }
67075
67076
67077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67079   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67080   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67081
67082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67083   arg2 = (Dali::SlotObserver *)jarg2;
67084   arg3 = (Dali::CallbackBase *)jarg3;
67085   {
67086     try {
67087       (arg1)->SignalDisconnected(arg2,arg3);
67088     } catch (std::out_of_range& e) {
67089       {
67090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67091       };
67092     } catch (std::exception& e) {
67093       {
67094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67095       };
67096     } catch (Dali::DaliException e) {
67097       {
67098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67099       };
67100     } catch (...) {
67101       {
67102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67103       };
67104     }
67105   }
67106
67107 }
67108
67109
67110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67112   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67113   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67114
67115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67116   arg2 = (Dali::SlotObserver *)jarg2;
67117   arg3 = (Dali::CallbackBase *)jarg3;
67118   {
67119     try {
67120       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67121     } catch (std::out_of_range& e) {
67122       {
67123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67124       };
67125     } catch (std::exception& e) {
67126       {
67127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67128       };
67129     } catch (Dali::DaliException e) {
67130       {
67131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67132       };
67133     } catch (...) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67136       };
67137     }
67138   }
67139
67140 }
67141
67142
67143 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) {
67144   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67145   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67146   if (director) {
67147     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);
67148   }
67149 }
67150
67151
67152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67153   void * jresult ;
67154   Dali::Toolkit::Control *arg1 = 0 ;
67155   Dali::Toolkit::Internal::Control *result = 0 ;
67156
67157   arg1 = (Dali::Toolkit::Control *)jarg1;
67158   if (!arg1) {
67159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67160     return 0;
67161   }
67162   {
67163     try {
67164       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67165     } catch (std::out_of_range& e) {
67166       {
67167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67168       };
67169     } catch (std::exception& e) {
67170       {
67171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67172       };
67173     } catch (Dali::DaliException e) {
67174       {
67175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67176       };
67177     } catch (...) {
67178       {
67179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67180       };
67181     }
67182   }
67183
67184   jresult = (void *)result;
67185   return jresult;
67186 }
67187
67188
67189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67190   int jresult ;
67191   int result;
67192
67193   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67194   jresult = (int)result;
67195   return jresult;
67196 }
67197
67198
67199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67200   int jresult ;
67201   int result;
67202
67203   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67204   jresult = (int)result;
67205   return jresult;
67206 }
67207
67208
67209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67210   int jresult ;
67211   int result;
67212
67213   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67214   jresult = (int)result;
67215   return jresult;
67216 }
67217
67218
67219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67220   int jresult ;
67221   int result;
67222
67223   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67224   jresult = (int)result;
67225   return jresult;
67226 }
67227
67228
67229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67230   int jresult ;
67231   int result;
67232
67233   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67234   jresult = (int)result;
67235   return jresult;
67236 }
67237
67238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67239   int jresult ;
67240   int result;
67241
67242   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67243   jresult = (int)result;
67244   return jresult;
67245 }
67246
67247
67248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67249   int jresult ;
67250   int result;
67251
67252   result = (int)Dali::Toolkit::Control::Property::PADDING;
67253   jresult = (int)result;
67254   return jresult;
67255 }
67256
67257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67258   void * jresult ;
67259   Dali::Toolkit::Control::Property *result = 0 ;
67260
67261   {
67262     try {
67263       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (Dali::DaliException e) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67275       };
67276     } catch (...) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67279       };
67280     }
67281   }
67282
67283   jresult = (void *)result;
67284   return jresult;
67285 }
67286
67287
67288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67289   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67290
67291   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67292   {
67293     try {
67294       delete arg1;
67295     } catch (std::out_of_range& e) {
67296       {
67297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67298       };
67299     } catch (std::exception& e) {
67300       {
67301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (Dali::DaliException e) {
67304       {
67305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67306       };
67307     } catch (...) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67310       };
67311     }
67312   }
67313
67314 }
67315
67316
67317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67318   void * jresult ;
67319   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67320
67321   {
67322     try {
67323       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67324     } catch (std::out_of_range& e) {
67325       {
67326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67327       };
67328     } catch (std::exception& e) {
67329       {
67330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67331       };
67332     } catch (Dali::DaliException e) {
67333       {
67334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67335       };
67336     } catch (...) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67339       };
67340     }
67341   }
67342
67343   jresult = (void *)result;
67344   return jresult;
67345 }
67346
67347
67348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67349   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67350
67351   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67352   {
67353     try {
67354       delete arg1;
67355     } catch (std::out_of_range& e) {
67356       {
67357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67358       };
67359     } catch (std::exception& e) {
67360       {
67361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67362       };
67363     } catch (Dali::DaliException e) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67366       };
67367     } catch (...) {
67368       {
67369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67370       };
67371     }
67372   }
67373
67374 }
67375
67376
67377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67378   void * jresult ;
67379   Dali::Toolkit::Control result;
67380
67381   {
67382     try {
67383       result = Dali::Toolkit::Control::New();
67384     } catch (std::out_of_range& e) {
67385       {
67386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67387       };
67388     } catch (std::exception& e) {
67389       {
67390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67391       };
67392     } catch (Dali::DaliException e) {
67393       {
67394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67399       };
67400     }
67401   }
67402
67403   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67404   return jresult;
67405 }
67406
67407
67408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67409   void * jresult ;
67410   Dali::Toolkit::Control *result = 0 ;
67411
67412   {
67413     try {
67414       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67415     } catch (std::out_of_range& e) {
67416       {
67417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67418       };
67419     } catch (std::exception& e) {
67420       {
67421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67422       };
67423     } catch (Dali::DaliException e) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67430       };
67431     }
67432   }
67433
67434   jresult = (void *)result;
67435   return jresult;
67436 }
67437
67438
67439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67440   void * jresult ;
67441   Dali::Toolkit::Control *arg1 = 0 ;
67442   Dali::Toolkit::Control *result = 0 ;
67443
67444   arg1 = (Dali::Toolkit::Control *)jarg1;
67445   if (!arg1) {
67446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67447     return 0;
67448   }
67449   {
67450     try {
67451       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67452     } catch (std::out_of_range& e) {
67453       {
67454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67455       };
67456     } catch (std::exception& e) {
67457       {
67458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67459       };
67460     } catch (Dali::DaliException e) {
67461       {
67462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67463       };
67464     } catch (...) {
67465       {
67466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67467       };
67468     }
67469   }
67470
67471   jresult = (void *)result;
67472   return jresult;
67473 }
67474
67475
67476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67477   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67478
67479   arg1 = (Dali::Toolkit::Control *)jarg1;
67480   {
67481     try {
67482       delete arg1;
67483     } catch (std::out_of_range& e) {
67484       {
67485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67486       };
67487     } catch (std::exception& e) {
67488       {
67489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67490       };
67491     } catch (Dali::DaliException e) {
67492       {
67493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67494       };
67495     } catch (...) {
67496       {
67497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67498       };
67499     }
67500   }
67501
67502 }
67503
67504
67505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67506   void * jresult ;
67507   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67508   Dali::Toolkit::Control *arg2 = 0 ;
67509   Dali::Toolkit::Control *result = 0 ;
67510
67511   arg1 = (Dali::Toolkit::Control *)jarg1;
67512   arg2 = (Dali::Toolkit::Control *)jarg2;
67513   if (!arg2) {
67514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67515     return 0;
67516   }
67517   {
67518     try {
67519       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67520     } catch (std::out_of_range& e) {
67521       {
67522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67523       };
67524     } catch (std::exception& e) {
67525       {
67526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67527       };
67528     } catch (Dali::DaliException e) {
67529       {
67530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67531       };
67532     } catch (...) {
67533       {
67534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67535       };
67536     }
67537   }
67538
67539   jresult = (void *)result;
67540   return jresult;
67541 }
67542
67543
67544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67545   void * jresult ;
67546   Dali::BaseHandle arg1 ;
67547   Dali::BaseHandle *argp1 ;
67548   Dali::Toolkit::Control result;
67549
67550   argp1 = (Dali::BaseHandle *)jarg1;
67551   if (!argp1) {
67552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67553     return 0;
67554   }
67555   arg1 = *argp1;
67556   {
67557     try {
67558       result = Dali::Toolkit::Control::DownCast(arg1);
67559     } catch (std::out_of_range& e) {
67560       {
67561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67562       };
67563     } catch (std::exception& e) {
67564       {
67565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67566       };
67567     } catch (Dali::DaliException e) {
67568       {
67569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67570       };
67571     } catch (...) {
67572       {
67573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67574       };
67575     }
67576   }
67577
67578   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67579   return jresult;
67580 }
67581
67582
67583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67584   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67585
67586   arg1 = (Dali::Toolkit::Control *)jarg1;
67587   {
67588     try {
67589       (arg1)->SetKeyInputFocus();
67590     } catch (std::out_of_range& e) {
67591       {
67592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67593       };
67594     } catch (std::exception& e) {
67595       {
67596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67597       };
67598     } catch (Dali::DaliException e) {
67599       {
67600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67601       };
67602     } catch (...) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67605       };
67606     }
67607   }
67608
67609 }
67610
67611
67612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67613   unsigned int jresult ;
67614   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67615   bool result;
67616
67617   arg1 = (Dali::Toolkit::Control *)jarg1;
67618   {
67619     try {
67620       result = (bool)(arg1)->HasKeyInputFocus();
67621     } catch (std::out_of_range& e) {
67622       {
67623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67624       };
67625     } catch (std::exception& e) {
67626       {
67627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67628       };
67629     } catch (Dali::DaliException e) {
67630       {
67631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67632       };
67633     } catch (...) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67636       };
67637     }
67638   }
67639
67640   jresult = result;
67641   return jresult;
67642 }
67643
67644
67645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67646   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67647
67648   arg1 = (Dali::Toolkit::Control *)jarg1;
67649   {
67650     try {
67651       (arg1)->ClearKeyInputFocus();
67652     } catch (std::out_of_range& e) {
67653       {
67654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67655       };
67656     } catch (std::exception& e) {
67657       {
67658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67659       };
67660     } catch (Dali::DaliException e) {
67661       {
67662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67663       };
67664     } catch (...) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67667       };
67668     }
67669   }
67670
67671 }
67672
67673
67674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67675   void * jresult ;
67676   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67677   Dali::PinchGestureDetector result;
67678
67679   arg1 = (Dali::Toolkit::Control *)jarg1;
67680   {
67681     try {
67682       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67683     } catch (std::out_of_range& e) {
67684       {
67685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67686       };
67687     } catch (std::exception& e) {
67688       {
67689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67690       };
67691     } catch (Dali::DaliException e) {
67692       {
67693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67694       };
67695     } catch (...) {
67696       {
67697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67698       };
67699     }
67700   }
67701
67702   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67703   return jresult;
67704 }
67705
67706
67707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67708   void * jresult ;
67709   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67710   Dali::PanGestureDetector result;
67711
67712   arg1 = (Dali::Toolkit::Control *)jarg1;
67713   {
67714     try {
67715       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67716     } catch (std::out_of_range& e) {
67717       {
67718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67719       };
67720     } catch (std::exception& e) {
67721       {
67722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67723       };
67724     } catch (Dali::DaliException e) {
67725       {
67726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67727       };
67728     } catch (...) {
67729       {
67730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67731       };
67732     }
67733   }
67734
67735   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67736   return jresult;
67737 }
67738
67739
67740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67741   void * jresult ;
67742   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67743   Dali::TapGestureDetector result;
67744
67745   arg1 = (Dali::Toolkit::Control *)jarg1;
67746   {
67747     try {
67748       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67749     } catch (std::out_of_range& e) {
67750       {
67751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67752       };
67753     } catch (std::exception& e) {
67754       {
67755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67756       };
67757     } catch (Dali::DaliException e) {
67758       {
67759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67760       };
67761     } catch (...) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67764       };
67765     }
67766   }
67767
67768   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67769   return jresult;
67770 }
67771
67772
67773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67774   void * jresult ;
67775   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67776   Dali::LongPressGestureDetector result;
67777
67778   arg1 = (Dali::Toolkit::Control *)jarg1;
67779   {
67780     try {
67781       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67782     } catch (std::out_of_range& e) {
67783       {
67784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67785       };
67786     } catch (std::exception& e) {
67787       {
67788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (Dali::DaliException e) {
67791       {
67792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67793       };
67794     } catch (...) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67797       };
67798     }
67799   }
67800
67801   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67802   return jresult;
67803 }
67804
67805
67806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67807   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67808   std::string *arg2 = 0 ;
67809
67810   arg1 = (Dali::Toolkit::Control *)jarg1;
67811   if (!jarg2) {
67812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67813     return ;
67814   }
67815   std::string arg2_str(jarg2);
67816   arg2 = &arg2_str;
67817   {
67818     try {
67819       (arg1)->SetStyleName((std::string const &)*arg2);
67820     } catch (std::out_of_range& e) {
67821       {
67822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67823       };
67824     } catch (std::exception& e) {
67825       {
67826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67827       };
67828     } catch (Dali::DaliException e) {
67829       {
67830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67831       };
67832     } catch (...) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67835       };
67836     }
67837   }
67838
67839
67840   //argout typemap for const std::string&
67841
67842 }
67843
67844
67845 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67846   char * jresult ;
67847   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67848   std::string *result = 0 ;
67849
67850   arg1 = (Dali::Toolkit::Control *)jarg1;
67851   {
67852     try {
67853       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67854     } catch (std::out_of_range& e) {
67855       {
67856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67857       };
67858     } catch (std::exception& e) {
67859       {
67860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67861       };
67862     } catch (Dali::DaliException e) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67869       };
67870     }
67871   }
67872
67873   jresult = SWIG_csharp_string_callback(result->c_str());
67874   return jresult;
67875 }
67876
67877
67878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67879   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67880   Dali::Vector4 *arg2 = 0 ;
67881
67882   arg1 = (Dali::Toolkit::Control *)jarg1;
67883   arg2 = (Dali::Vector4 *)jarg2;
67884   if (!arg2) {
67885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67886     return ;
67887   }
67888   {
67889     try {
67890       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67891     } catch (std::out_of_range& e) {
67892       {
67893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67894       };
67895     } catch (std::exception& e) {
67896       {
67897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67898       };
67899     } catch (Dali::DaliException e) {
67900       {
67901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67902       };
67903     } catch (...) {
67904       {
67905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67906       };
67907     }
67908   }
67909
67910 }
67911
67912
67913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67914   void * jresult ;
67915   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67916   Dali::Vector4 result;
67917
67918   arg1 = (Dali::Toolkit::Control *)jarg1;
67919   {
67920     try {
67921       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67922     } catch (std::out_of_range& e) {
67923       {
67924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (std::exception& e) {
67927       {
67928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (Dali::DaliException e) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67933       };
67934     } catch (...) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67937       };
67938     }
67939   }
67940
67941   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67942   return jresult;
67943 }
67944
67945
67946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67947   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67948   Dali::Image arg2 ;
67949   Dali::Image *argp2 ;
67950
67951   arg1 = (Dali::Toolkit::Control *)jarg1;
67952   argp2 = (Dali::Image *)jarg2;
67953   if (!argp2) {
67954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67955     return ;
67956   }
67957   arg2 = *argp2;
67958   {
67959     try {
67960       (arg1)->SetBackgroundImage(arg2);
67961     } catch (std::out_of_range& e) {
67962       {
67963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67964       };
67965     } catch (std::exception& e) {
67966       {
67967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67968       };
67969     } catch (Dali::DaliException e) {
67970       {
67971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67972       };
67973     } catch (...) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67976       };
67977     }
67978   }
67979
67980 }
67981
67982
67983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67984   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67985
67986   arg1 = (Dali::Toolkit::Control *)jarg1;
67987   {
67988     try {
67989       (arg1)->ClearBackground();
67990     } catch (std::out_of_range& e) {
67991       {
67992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67993       };
67994     } catch (std::exception& e) {
67995       {
67996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67997       };
67998     } catch (Dali::DaliException e) {
67999       {
68000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68001       };
68002     } catch (...) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68005       };
68006     }
68007   }
68008
68009 }
68010
68011
68012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68013   void * jresult ;
68014   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68015   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68016
68017   arg1 = (Dali::Toolkit::Control *)jarg1;
68018   {
68019     try {
68020       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68021     } catch (std::out_of_range& e) {
68022       {
68023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68024       };
68025     } catch (std::exception& e) {
68026       {
68027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68028       };
68029     } catch (Dali::DaliException e) {
68030       {
68031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68032       };
68033     } catch (...) {
68034       {
68035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68036       };
68037     }
68038   }
68039
68040   jresult = (void *)result;
68041   return jresult;
68042 }
68043
68044
68045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68046   void * jresult ;
68047   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68048   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68049
68050   arg1 = (Dali::Toolkit::Control *)jarg1;
68051   {
68052     try {
68053       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68054     } catch (std::out_of_range& e) {
68055       {
68056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (std::exception& e) {
68059       {
68060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (Dali::DaliException e) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68065       };
68066     } catch (...) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68069       };
68070     }
68071   }
68072
68073   jresult = (void *)result;
68074   return jresult;
68075 }
68076
68077
68078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68079   void * jresult ;
68080   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68081   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68082
68083   arg1 = (Dali::Toolkit::Control *)jarg1;
68084   {
68085     try {
68086       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68087     } catch (std::out_of_range& e) {
68088       {
68089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68090       };
68091     } catch (std::exception& e) {
68092       {
68093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68094       };
68095     } catch (Dali::DaliException e) {
68096       {
68097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68098       };
68099     } catch (...) {
68100       {
68101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68102       };
68103     }
68104   }
68105
68106   jresult = (void *)result;
68107   return jresult;
68108 }
68109
68110
68111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68112   void * jresult ;
68113   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68114   Dali::Toolkit::Control *result = 0 ;
68115
68116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68117   if (!arg1) {
68118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68119     return 0;
68120   }
68121   {
68122     try {
68123       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68124     } catch (std::out_of_range& e) {
68125       {
68126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (std::exception& e) {
68129       {
68130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (Dali::DaliException e) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68135       };
68136     } catch (...) {
68137       {
68138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68139       };
68140     }
68141   }
68142
68143   jresult = (void *)result;
68144   return jresult;
68145 }
68146
68147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68148 {
68149   int jresult;
68150   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68151   arg1 = (Dali::Toolkit::Control *)jarg1;
68152
68153   if (!arg1) {
68154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68155     return 0;
68156   }
68157
68158   Dali::Property::Index arg2 = 0 ;
68159   arg2 = (Dali::Property::Index)jarg2;
68160
68161   Toolkit::Visual::ResourceStatus result;
68162   {
68163     try {
68164       result = arg1->GetVisualResourceStatus(arg2);
68165     } catch (std::out_of_range& e) {
68166       {
68167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68168       };
68169     } catch (std::exception& e) {
68170       {
68171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (...) {
68174       {
68175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68176       };
68177     }
68178   }
68179   jresult = (int)(result);
68180   return jresult;
68181 }
68182
68183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68184 {
68185   void * jresult;
68186   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68187   arg1 = (Dali::Toolkit::Control *)jarg1;
68188
68189   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68190
68191   Dali::Toolkit::TransitionData *arg2 = 0 ;
68192   Dali::Animation result;
68193
68194   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68195   if (!arg2) {
68196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68197     return 0;
68198   }
68199   {
68200     try {
68201       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68202     } catch (std::out_of_range& e) {
68203       {
68204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (std::exception& e) {
68207       {
68208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (Dali::DaliException e) {
68211       {
68212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68213       };
68214     } catch (...) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68217       };
68218     }
68219   }
68220
68221   jresult = new Dali::Animation((const Dali::Animation &)result);
68222   return jresult;
68223 }
68224
68225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68226 {
68227   Dali::Toolkit::Control arg1;
68228   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68229
68230   if (!argp1) {
68231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68232   }
68233   arg1 = *argp1;
68234
68235   Dali::Property::Index arg2 = 0 ;
68236   arg2 = (Dali::Property::Index)jarg2;
68237
68238   Dali::Property::Index arg3 = 0 ;
68239   arg3 = (Dali::Property::Index)jarg3;
68240
68241   Dali::Property::Value arg4;
68242   arg4 = (Dali::Property::Value *)jarg4;
68243
68244   {
68245     try {
68246       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68254       };
68255     } catch (...) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68258       };
68259     }
68260   }
68261
68262
68263 }
68264
68265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68266   void * jresult ;
68267   Dali::Toolkit::Control *arg1 = 0 ;
68268   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68269
68270   arg1 = (Dali::Toolkit::Control *)jarg1;
68271   if (!arg1) {
68272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68273     return 0;
68274   }
68275   {
68276     try {
68277       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68278     } catch (std::out_of_range& e) {
68279       {
68280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68281       };
68282     } catch (std::exception& e) {
68283       {
68284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (Dali::DaliException e) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68289       };
68290     } catch (...) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68293       };
68294     }
68295   }
68296
68297   jresult = (void *)result;
68298   return jresult;
68299 }
68300
68301
68302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68303   unsigned int jresult ;
68304   Dali::Toolkit::Control *arg1 = 0 ;
68305   bool result;
68306
68307   arg1 = (Dali::Toolkit::Control *)jarg1;
68308   if (!arg1) {
68309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68310     return 0;
68311   }
68312   {
68313     try {
68314       result = (bool)arg1->IsResourceReady();
68315     } catch (std::out_of_range& e) {
68316       {
68317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68318       };
68319     } catch (std::exception& e) {
68320       {
68321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68322       };
68323     } catch (Dali::DaliException e) {
68324       {
68325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68326       };
68327     } catch (...) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68330       };
68331     }
68332   }
68333
68334   jresult = result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68340   void * jresult ;
68341   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68342
68343   {
68344     try {
68345       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (Dali::DaliException e) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68361       };
68362     }
68363   }
68364
68365   jresult = (void *)result;
68366   return jresult;
68367 }
68368
68369
68370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68371   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68372
68373   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68374   {
68375     try {
68376       delete arg1;
68377     } catch (std::out_of_range& e) {
68378       {
68379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68380       };
68381     } catch (std::exception& e) {
68382       {
68383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68384       };
68385     } catch (Dali::DaliException e) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68388       };
68389     } catch (...) {
68390       {
68391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68392       };
68393     }
68394   }
68395
68396 }
68397
68398
68399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68400   void * jresult ;
68401   Dali::Toolkit::KeyInputFocusManager result;
68402
68403   {
68404     try {
68405       result = Dali::Toolkit::KeyInputFocusManager::Get();
68406     } catch (std::out_of_range& e) {
68407       {
68408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (std::exception& e) {
68411       {
68412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68413       };
68414     } catch (Dali::DaliException e) {
68415       {
68416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68417       };
68418     } catch (...) {
68419       {
68420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68421       };
68422     }
68423   }
68424
68425   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68426   return jresult;
68427 }
68428
68429
68430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68431   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68432   Dali::Toolkit::Control arg2 ;
68433   Dali::Toolkit::Control *argp2 ;
68434
68435   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68436   argp2 = (Dali::Toolkit::Control *)jarg2;
68437   if (!argp2) {
68438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68439     return ;
68440   }
68441   arg2 = *argp2;
68442   {
68443     try {
68444       (arg1)->SetFocus(arg2);
68445     } catch (std::out_of_range& e) {
68446       {
68447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68448       };
68449     } catch (std::exception& e) {
68450       {
68451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68452       };
68453     } catch (Dali::DaliException e) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68456       };
68457     } catch (...) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68460       };
68461     }
68462   }
68463
68464 }
68465
68466
68467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68468   void * jresult ;
68469   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68470   Dali::Toolkit::Control result;
68471
68472   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68473   {
68474     try {
68475       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68476     } catch (std::out_of_range& e) {
68477       {
68478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68479       };
68480     } catch (std::exception& e) {
68481       {
68482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (Dali::DaliException e) {
68485       {
68486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68487       };
68488     } catch (...) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68491       };
68492     }
68493   }
68494
68495   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68496   return jresult;
68497 }
68498
68499
68500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68501   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68502   Dali::Toolkit::Control arg2 ;
68503   Dali::Toolkit::Control *argp2 ;
68504
68505   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68506   argp2 = (Dali::Toolkit::Control *)jarg2;
68507   if (!argp2) {
68508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68509     return ;
68510   }
68511   arg2 = *argp2;
68512   {
68513     try {
68514       (arg1)->RemoveFocus(arg2);
68515     } catch (std::out_of_range& e) {
68516       {
68517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68518       };
68519     } catch (std::exception& e) {
68520       {
68521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68522       };
68523     } catch (Dali::DaliException e) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68526       };
68527     } catch (...) {
68528       {
68529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68530       };
68531     }
68532   }
68533
68534 }
68535
68536
68537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68538   void * jresult ;
68539   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68540   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68541
68542   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68543   {
68544     try {
68545       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68546     } catch (std::out_of_range& e) {
68547       {
68548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68549       };
68550     } catch (std::exception& e) {
68551       {
68552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (Dali::DaliException e) {
68555       {
68556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68561       };
68562     }
68563   }
68564
68565   jresult = (void *)result;
68566   return jresult;
68567 }
68568
68569
68570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68571   void * jresult ;
68572   Dali::Toolkit::Alignment::Padding *result = 0 ;
68573
68574   {
68575     try {
68576       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68577     } catch (std::out_of_range& e) {
68578       {
68579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68580       };
68581     } catch (std::exception& e) {
68582       {
68583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68584       };
68585     } catch (Dali::DaliException e) {
68586       {
68587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68588       };
68589     } catch (...) {
68590       {
68591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68592       };
68593     }
68594   }
68595
68596   jresult = (void *)result;
68597   return jresult;
68598 }
68599
68600
68601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68602   void * jresult ;
68603   float arg1 ;
68604   float arg2 ;
68605   float arg3 ;
68606   float arg4 ;
68607   Dali::Toolkit::Alignment::Padding *result = 0 ;
68608
68609   arg1 = (float)jarg1;
68610   arg2 = (float)jarg2;
68611   arg3 = (float)jarg3;
68612   arg4 = (float)jarg4;
68613   {
68614     try {
68615       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68616     } catch (std::out_of_range& e) {
68617       {
68618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (std::exception& e) {
68621       {
68622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (Dali::DaliException e) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68627       };
68628     } catch (...) {
68629       {
68630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68631       };
68632     }
68633   }
68634
68635   jresult = (void *)result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68641   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68642   float arg2 ;
68643
68644   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68645   arg2 = (float)jarg2;
68646   if (arg1) (arg1)->left = arg2;
68647 }
68648
68649
68650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68651   float jresult ;
68652   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68653   float result;
68654
68655   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68656   result = (float) ((arg1)->left);
68657   jresult = result;
68658   return jresult;
68659 }
68660
68661
68662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68663   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68664   float arg2 ;
68665
68666   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68667   arg2 = (float)jarg2;
68668   if (arg1) (arg1)->right = arg2;
68669 }
68670
68671
68672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68673   float jresult ;
68674   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68675   float result;
68676
68677   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68678   result = (float) ((arg1)->right);
68679   jresult = result;
68680   return jresult;
68681 }
68682
68683
68684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68685   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68686   float arg2 ;
68687
68688   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68689   arg2 = (float)jarg2;
68690   if (arg1) (arg1)->top = arg2;
68691 }
68692
68693
68694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68695   float jresult ;
68696   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68697   float result;
68698
68699   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68700   result = (float) ((arg1)->top);
68701   jresult = result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68707   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68708   float arg2 ;
68709
68710   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68711   arg2 = (float)jarg2;
68712   if (arg1) (arg1)->bottom = arg2;
68713 }
68714
68715
68716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68717   float jresult ;
68718   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68719   float result;
68720
68721   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68722   result = (float) ((arg1)->bottom);
68723   jresult = result;
68724   return jresult;
68725 }
68726
68727
68728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68729   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68730
68731   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68732   {
68733     try {
68734       delete arg1;
68735     } catch (std::out_of_range& e) {
68736       {
68737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68738       };
68739     } catch (std::exception& e) {
68740       {
68741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68742       };
68743     } catch (Dali::DaliException e) {
68744       {
68745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68746       };
68747     } catch (...) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68750       };
68751     }
68752   }
68753
68754 }
68755
68756
68757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68758   void * jresult ;
68759   Dali::Toolkit::Alignment *result = 0 ;
68760
68761   {
68762     try {
68763       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68764     } catch (std::out_of_range& e) {
68765       {
68766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68767       };
68768     } catch (std::exception& e) {
68769       {
68770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (Dali::DaliException e) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68775       };
68776     } catch (...) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68779       };
68780     }
68781   }
68782
68783   jresult = (void *)result;
68784   return jresult;
68785 }
68786
68787
68788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68789   void * jresult ;
68790   Dali::Toolkit::Alignment::Type arg1 ;
68791   Dali::Toolkit::Alignment::Type arg2 ;
68792   Dali::Toolkit::Alignment result;
68793
68794   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68795   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68796   {
68797     try {
68798       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68799     } catch (std::out_of_range& e) {
68800       {
68801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (std::exception& e) {
68804       {
68805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (Dali::DaliException e) {
68808       {
68809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68810       };
68811     } catch (...) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68814       };
68815     }
68816   }
68817
68818   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68819   return jresult;
68820 }
68821
68822
68823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68824   void * jresult ;
68825   Dali::Toolkit::Alignment::Type arg1 ;
68826   Dali::Toolkit::Alignment result;
68827
68828   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68829   {
68830     try {
68831       result = Dali::Toolkit::Alignment::New(arg1);
68832     } catch (std::out_of_range& e) {
68833       {
68834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (std::exception& e) {
68837       {
68838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (Dali::DaliException e) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68843       };
68844     } catch (...) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68847       };
68848     }
68849   }
68850
68851   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68852   return jresult;
68853 }
68854
68855
68856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68857   void * jresult ;
68858   Dali::Toolkit::Alignment result;
68859
68860   {
68861     try {
68862       result = Dali::Toolkit::Alignment::New();
68863     } catch (std::out_of_range& e) {
68864       {
68865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (std::exception& e) {
68868       {
68869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (Dali::DaliException e) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68874       };
68875     } catch (...) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68878       };
68879     }
68880   }
68881
68882   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68883   return jresult;
68884 }
68885
68886
68887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68888   void * jresult ;
68889   Dali::Toolkit::Alignment *arg1 = 0 ;
68890   Dali::Toolkit::Alignment *result = 0 ;
68891
68892   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68893   if (!arg1) {
68894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68895     return 0;
68896   }
68897   {
68898     try {
68899       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68900     } catch (std::out_of_range& e) {
68901       {
68902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68903       };
68904     } catch (std::exception& e) {
68905       {
68906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68907       };
68908     } catch (Dali::DaliException e) {
68909       {
68910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68915       };
68916     }
68917   }
68918
68919   jresult = (void *)result;
68920   return jresult;
68921 }
68922
68923
68924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68925   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68926
68927   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68928   {
68929     try {
68930       delete arg1;
68931     } catch (std::out_of_range& e) {
68932       {
68933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68934       };
68935     } catch (std::exception& e) {
68936       {
68937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (Dali::DaliException e) {
68940       {
68941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68942       };
68943     } catch (...) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68946       };
68947     }
68948   }
68949
68950 }
68951
68952
68953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68954   void * jresult ;
68955   Dali::BaseHandle arg1 ;
68956   Dali::BaseHandle *argp1 ;
68957   Dali::Toolkit::Alignment result;
68958
68959   argp1 = (Dali::BaseHandle *)jarg1;
68960   if (!argp1) {
68961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68962     return 0;
68963   }
68964   arg1 = *argp1;
68965   {
68966     try {
68967       result = Dali::Toolkit::Alignment::DownCast(arg1);
68968     } catch (std::out_of_range& e) {
68969       {
68970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68971       };
68972     } catch (std::exception& e) {
68973       {
68974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68975       };
68976     } catch (Dali::DaliException e) {
68977       {
68978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68979       };
68980     } catch (...) {
68981       {
68982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68983       };
68984     }
68985   }
68986
68987   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68988   return jresult;
68989 }
68990
68991
68992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68993   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68994   Dali::Toolkit::Alignment::Type arg2 ;
68995
68996   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68997   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68998   {
68999     try {
69000       (arg1)->SetAlignmentType(arg2);
69001     } catch (std::out_of_range& e) {
69002       {
69003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69004       };
69005     } catch (std::exception& e) {
69006       {
69007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69008       };
69009     } catch (Dali::DaliException e) {
69010       {
69011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69012       };
69013     } catch (...) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69016       };
69017     }
69018   }
69019
69020 }
69021
69022
69023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69024   int jresult ;
69025   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69026   Dali::Toolkit::Alignment::Type result;
69027
69028   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69029   {
69030     try {
69031       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69032     } catch (std::out_of_range& e) {
69033       {
69034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (std::exception& e) {
69037       {
69038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (Dali::DaliException e) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69043       };
69044     } catch (...) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69047       };
69048     }
69049   }
69050
69051   jresult = (int)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69057   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69058   Dali::Toolkit::Alignment::Scaling arg2 ;
69059
69060   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69061   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69062   {
69063     try {
69064       (arg1)->SetScaling(arg2);
69065     } catch (std::out_of_range& e) {
69066       {
69067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69068       };
69069     } catch (std::exception& e) {
69070       {
69071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69072       };
69073     } catch (Dali::DaliException e) {
69074       {
69075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69080       };
69081     }
69082   }
69083
69084 }
69085
69086
69087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69088   int jresult ;
69089   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69090   Dali::Toolkit::Alignment::Scaling result;
69091
69092   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69093   {
69094     try {
69095       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (Dali::DaliException e) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69111       };
69112     }
69113   }
69114
69115   jresult = (int)result;
69116   return jresult;
69117 }
69118
69119
69120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69121   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69122   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69123
69124   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69125   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69126   if (!arg2) {
69127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69128     return ;
69129   }
69130   {
69131     try {
69132       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69133     } catch (std::out_of_range& e) {
69134       {
69135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69136       };
69137     } catch (std::exception& e) {
69138       {
69139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69140       };
69141     } catch (Dali::DaliException e) {
69142       {
69143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69144       };
69145     } catch (...) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69148       };
69149     }
69150   }
69151
69152 }
69153
69154
69155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69156   void * jresult ;
69157   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69158   Dali::Toolkit::Alignment::Padding *result = 0 ;
69159
69160   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69161   {
69162     try {
69163       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69164     } catch (std::out_of_range& e) {
69165       {
69166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69167       };
69168     } catch (std::exception& e) {
69169       {
69170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (Dali::DaliException e) {
69173       {
69174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69175       };
69176     } catch (...) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69179       };
69180     }
69181   }
69182
69183   jresult = (void *)result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69189   void * jresult ;
69190   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69191   Dali::Toolkit::Alignment *arg2 = 0 ;
69192   Dali::Toolkit::Alignment *result = 0 ;
69193
69194   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69195   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69196   if (!arg2) {
69197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69198     return 0;
69199   }
69200   {
69201     try {
69202       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (Dali::DaliException e) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221
69222   jresult = (void *)result;
69223   return jresult;
69224 }
69225
69226
69227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69228   int jresult ;
69229   int result;
69230
69231   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69232   jresult = (int)result;
69233   return jresult;
69234 }
69235
69236
69237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69238   int jresult ;
69239   int result;
69240
69241   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69242   jresult = (int)result;
69243   return jresult;
69244 }
69245
69246
69247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69248   int jresult ;
69249   int result;
69250
69251   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69252   jresult = (int)result;
69253   return jresult;
69254 }
69255
69256
69257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69258   int jresult ;
69259   int result;
69260
69261   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69262   jresult = (int)result;
69263   return jresult;
69264 }
69265
69266
69267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69268   int jresult ;
69269   int result;
69270
69271   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69272   jresult = (int)result;
69273   return jresult;
69274 }
69275
69276
69277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69278   int jresult ;
69279   int result;
69280
69281   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69282   jresult = (int)result;
69283   return jresult;
69284 }
69285
69286
69287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69288   int jresult ;
69289   int result;
69290
69291   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69292   jresult = (int)result;
69293   return jresult;
69294 }
69295
69296
69297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69298   int jresult ;
69299   int result;
69300
69301   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69302   jresult = (int)result;
69303   return jresult;
69304 }
69305
69306
69307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69308   int jresult ;
69309   int result;
69310
69311   result = (int)Dali::Toolkit::Button::Property::LABEL;
69312   jresult = (int)result;
69313   return jresult;
69314 }
69315
69316
69317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69318   int jresult ;
69319   int result;
69320
69321   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69322   jresult = (int)result;
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69328   void * jresult ;
69329   Dali::Toolkit::Button::Property *result = 0 ;
69330
69331   {
69332     try {
69333       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69334     } catch (std::out_of_range& e) {
69335       {
69336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69337       };
69338     } catch (std::exception& e) {
69339       {
69340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69341       };
69342     } catch (Dali::DaliException e) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69345       };
69346     } catch (...) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69349       };
69350     }
69351   }
69352
69353   jresult = (void *)result;
69354   return jresult;
69355 }
69356
69357
69358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69359   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69360
69361   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69362   {
69363     try {
69364       delete arg1;
69365     } catch (std::out_of_range& e) {
69366       {
69367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69368       };
69369     } catch (std::exception& e) {
69370       {
69371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69372       };
69373     } catch (Dali::DaliException e) {
69374       {
69375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69376       };
69377     } catch (...) {
69378       {
69379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69380       };
69381     }
69382   }
69383
69384 }
69385
69386
69387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69388   void * jresult ;
69389   Dali::Toolkit::Button *result = 0 ;
69390
69391   {
69392     try {
69393       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69394     } catch (std::out_of_range& e) {
69395       {
69396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69397       };
69398     } catch (std::exception& e) {
69399       {
69400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69401       };
69402     } catch (Dali::DaliException e) {
69403       {
69404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69405       };
69406     } catch (...) {
69407       {
69408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69409       };
69410     }
69411   }
69412
69413   jresult = (void *)result;
69414   return jresult;
69415 }
69416
69417
69418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69419   void * jresult ;
69420   Dali::Toolkit::Button *arg1 = 0 ;
69421   Dali::Toolkit::Button *result = 0 ;
69422
69423   arg1 = (Dali::Toolkit::Button *)jarg1;
69424   if (!arg1) {
69425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69426     return 0;
69427   }
69428   {
69429     try {
69430       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69431     } catch (std::out_of_range& e) {
69432       {
69433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69434       };
69435     } catch (std::exception& e) {
69436       {
69437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69438       };
69439     } catch (Dali::DaliException e) {
69440       {
69441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69442       };
69443     } catch (...) {
69444       {
69445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69446       };
69447     }
69448   }
69449
69450   jresult = (void *)result;
69451   return jresult;
69452 }
69453
69454
69455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69456   void * jresult ;
69457   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69458   Dali::Toolkit::Button *arg2 = 0 ;
69459   Dali::Toolkit::Button *result = 0 ;
69460
69461   arg1 = (Dali::Toolkit::Button *)jarg1;
69462   arg2 = (Dali::Toolkit::Button *)jarg2;
69463   if (!arg2) {
69464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69465     return 0;
69466   }
69467   {
69468     try {
69469       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69470     } catch (std::out_of_range& e) {
69471       {
69472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69473       };
69474     } catch (std::exception& e) {
69475       {
69476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (Dali::DaliException e) {
69479       {
69480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69481       };
69482     } catch (...) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69485       };
69486     }
69487   }
69488
69489   jresult = (void *)result;
69490   return jresult;
69491 }
69492
69493
69494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69495   void * jresult ;
69496   Dali::BaseHandle arg1 ;
69497   Dali::BaseHandle *argp1 ;
69498   Dali::Toolkit::Button result;
69499
69500   argp1 = (Dali::BaseHandle *)jarg1;
69501   if (!argp1) {
69502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69503     return 0;
69504   }
69505   arg1 = *argp1;
69506   {
69507     try {
69508       result = Dali::Toolkit::Button::DownCast(arg1);
69509     } catch (std::out_of_range& e) {
69510       {
69511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (std::exception& e) {
69514       {
69515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69516       };
69517     } catch (Dali::DaliException e) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69520       };
69521     } catch (...) {
69522       {
69523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69524       };
69525     }
69526   }
69527
69528   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69534   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69535
69536   arg1 = (Dali::Toolkit::Button *)jarg1;
69537   {
69538     try {
69539       delete arg1;
69540     } catch (std::out_of_range& e) {
69541       {
69542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69543       };
69544     } catch (std::exception& e) {
69545       {
69546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69547       };
69548     } catch (Dali::DaliException e) {
69549       {
69550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69551       };
69552     } catch (...) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69555       };
69556     }
69557   }
69558
69559 }
69560
69561
69562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69563   unsigned int jresult ;
69564   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69565   bool result;
69566
69567   arg1 = (Dali::Toolkit::Button *)jarg1;
69568   {
69569     try {
69570       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69571     } catch (std::out_of_range& e) {
69572       {
69573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69574       };
69575     } catch (std::exception& e) {
69576       {
69577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (Dali::DaliException e) {
69580       {
69581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69582       };
69583     } catch (...) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69586       };
69587     }
69588   }
69589
69590   jresult = result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69596   unsigned int jresult ;
69597   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69598   bool result;
69599
69600   arg1 = (Dali::Toolkit::Button *)jarg1;
69601   {
69602     try {
69603       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69604     } catch (std::out_of_range& e) {
69605       {
69606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69607       };
69608     } catch (std::exception& e) {
69609       {
69610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69611       };
69612     } catch (Dali::DaliException e) {
69613       {
69614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69615       };
69616     } catch (...) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69619       };
69620     }
69621   }
69622
69623   jresult = result;
69624   return jresult;
69625 }
69626
69627
69628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69629   float jresult ;
69630   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69631   float result;
69632
69633   arg1 = (Dali::Toolkit::Button *)jarg1;
69634   {
69635     try {
69636       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69637     } catch (std::out_of_range& e) {
69638       {
69639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69640       };
69641     } catch (std::exception& e) {
69642       {
69643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (Dali::DaliException e) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655
69656   jresult = result;
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69662   float jresult ;
69663   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69664   float result;
69665
69666   arg1 = (Dali::Toolkit::Button *)jarg1;
69667   {
69668     try {
69669       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69670     } catch (std::out_of_range& e) {
69671       {
69672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69673       };
69674     } catch (std::exception& e) {
69675       {
69676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69677       };
69678     } catch (Dali::DaliException e) {
69679       {
69680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69681       };
69682     } catch (...) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69685       };
69686     }
69687   }
69688
69689   jresult = result;
69690   return jresult;
69691 }
69692
69693
69694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69695   unsigned int jresult ;
69696   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69697   bool result;
69698
69699   arg1 = (Dali::Toolkit::Button *)jarg1;
69700   {
69701     try {
69702       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69718       };
69719     }
69720   }
69721
69722   jresult = result;
69723   return jresult;
69724 }
69725
69726
69727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69728   unsigned int jresult ;
69729   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69730   bool result;
69731
69732   arg1 = (Dali::Toolkit::Button *)jarg1;
69733   {
69734     try {
69735       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69736     } catch (std::out_of_range& e) {
69737       {
69738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69739       };
69740     } catch (std::exception& e) {
69741       {
69742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69743       };
69744     } catch (Dali::DaliException e) {
69745       {
69746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69747       };
69748     } catch (...) {
69749       {
69750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69751       };
69752     }
69753   }
69754
69755   jresult = result;
69756   return jresult;
69757 }
69758
69759
69760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69761   float jresult ;
69762   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69763   float result;
69764
69765   arg1 = (Dali::Toolkit::Button *)jarg1;
69766   {
69767     try {
69768       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (Dali::DaliException e) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69780       };
69781     } catch (...) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69784       };
69785     }
69786   }
69787
69788   jresult = result;
69789   return jresult;
69790 }
69791
69792
69793 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69794   char * jresult ;
69795   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69796   std::string result;
69797
69798   arg1 = (Dali::Toolkit::Button *)jarg1;
69799   {
69800     try {
69801       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69802     } catch (std::out_of_range& e) {
69803       {
69804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (std::exception& e) {
69807       {
69808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (Dali::DaliException e) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69817       };
69818     }
69819   }
69820
69821   jresult = SWIG_csharp_string_callback((&result)->c_str());
69822   return jresult;
69823 }
69824
69825
69826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69827   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69828   Dali::Actor arg2 ;
69829   Dali::Actor *argp2 ;
69830
69831   arg1 = (Dali::Toolkit::Button *)jarg1;
69832   argp2 = (Dali::Actor *)jarg2;
69833   if (!argp2) {
69834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69835     return ;
69836   }
69837   arg2 = *argp2;
69838   {
69839     try {
69840       (arg1)->SetLabel(arg2);
69841     } catch (std::out_of_range& e) {
69842       {
69843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69844       };
69845     } catch (std::exception& e) {
69846       {
69847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69848       };
69849     } catch (Dali::DaliException e) {
69850       {
69851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69856       };
69857     }
69858   }
69859
69860 }
69861
69862
69863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69864   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69865   Dali::Image arg2 ;
69866   Dali::Image *argp2 ;
69867
69868   arg1 = (Dali::Toolkit::Button *)jarg1;
69869   argp2 = (Dali::Image *)jarg2;
69870   if (!argp2) {
69871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69872     return ;
69873   }
69874   arg2 = *argp2;
69875   {
69876     try {
69877       (arg1)->SetButtonImage(arg2);
69878     } catch (std::out_of_range& e) {
69879       {
69880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69881       };
69882     } catch (std::exception& e) {
69883       {
69884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (Dali::DaliException e) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69893       };
69894     }
69895   }
69896
69897 }
69898
69899
69900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69901   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69902   Dali::Image arg2 ;
69903   Dali::Image *argp2 ;
69904
69905   arg1 = (Dali::Toolkit::Button *)jarg1;
69906   argp2 = (Dali::Image *)jarg2;
69907   if (!argp2) {
69908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69909     return ;
69910   }
69911   arg2 = *argp2;
69912   {
69913     try {
69914       (arg1)->SetSelectedImage(arg2);
69915     } catch (std::out_of_range& e) {
69916       {
69917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69918       };
69919     } catch (std::exception& e) {
69920       {
69921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69922       };
69923     } catch (Dali::DaliException e) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69926       };
69927     } catch (...) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69930       };
69931     }
69932   }
69933
69934 }
69935
69936
69937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69938   void * jresult ;
69939   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69940   Dali::Actor result;
69941
69942   arg1 = (Dali::Toolkit::Button *)jarg1;
69943   {
69944     try {
69945       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69946     } catch (std::out_of_range& e) {
69947       {
69948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (std::exception& e) {
69951       {
69952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (Dali::DaliException e) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69957       };
69958     } catch (...) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69961       };
69962     }
69963   }
69964
69965   jresult = new Dali::Actor((const Dali::Actor &)result);
69966   return jresult;
69967 }
69968
69969
69970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69971   void * jresult ;
69972   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69973   Dali::Actor result;
69974
69975   arg1 = (Dali::Toolkit::Button *)jarg1;
69976   {
69977     try {
69978       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69979     } catch (std::out_of_range& e) {
69980       {
69981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (std::exception& e) {
69984       {
69985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69986       };
69987     } catch (Dali::DaliException e) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69990       };
69991     } catch (...) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69994       };
69995     }
69996   }
69997
69998   jresult = new Dali::Actor((const Dali::Actor &)result);
69999   return jresult;
70000 }
70001
70002
70003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70004   void * jresult ;
70005   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70006   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70007
70008   arg1 = (Dali::Toolkit::Button *)jarg1;
70009   {
70010     try {
70011       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70012     } catch (std::out_of_range& e) {
70013       {
70014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70015       };
70016     } catch (std::exception& e) {
70017       {
70018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70019       };
70020     } catch (Dali::DaliException e) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70023       };
70024     } catch (...) {
70025       {
70026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70027       };
70028     }
70029   }
70030
70031   jresult = (void *)result;
70032   return jresult;
70033 }
70034
70035
70036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70037   void * jresult ;
70038   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70039   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70040
70041   arg1 = (Dali::Toolkit::Button *)jarg1;
70042   {
70043     try {
70044       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70045     } catch (std::out_of_range& e) {
70046       {
70047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (std::exception& e) {
70050       {
70051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (Dali::DaliException e) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70060       };
70061     }
70062   }
70063
70064   jresult = (void *)result;
70065   return jresult;
70066 }
70067
70068
70069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70070   void * jresult ;
70071   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70072   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70073
70074   arg1 = (Dali::Toolkit::Button *)jarg1;
70075   {
70076     try {
70077       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70078     } catch (std::out_of_range& e) {
70079       {
70080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (std::exception& e) {
70083       {
70084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (Dali::DaliException e) {
70087       {
70088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70089       };
70090     } catch (...) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70093       };
70094     }
70095   }
70096
70097   jresult = (void *)result;
70098   return jresult;
70099 }
70100
70101
70102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70103   void * jresult ;
70104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70105   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70106
70107   arg1 = (Dali::Toolkit::Button *)jarg1;
70108   {
70109     try {
70110       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70111     } catch (std::out_of_range& e) {
70112       {
70113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (std::exception& e) {
70116       {
70117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70118       };
70119     } catch (Dali::DaliException e) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70122       };
70123     } catch (...) {
70124       {
70125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70126       };
70127     }
70128   }
70129
70130   jresult = (void *)result;
70131   return jresult;
70132 }
70133
70134
70135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70136   void * jresult ;
70137   Dali::Toolkit::CheckBoxButton *result = 0 ;
70138
70139   {
70140     try {
70141       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70142     } catch (std::out_of_range& e) {
70143       {
70144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (std::exception& e) {
70147       {
70148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (Dali::DaliException e) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70157       };
70158     }
70159   }
70160
70161   jresult = (void *)result;
70162   return jresult;
70163 }
70164
70165
70166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70167   void * jresult ;
70168   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70169   Dali::Toolkit::CheckBoxButton *result = 0 ;
70170
70171   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70172   if (!arg1) {
70173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70174     return 0;
70175   }
70176   {
70177     try {
70178       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70179     } catch (std::out_of_range& e) {
70180       {
70181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70182       };
70183     } catch (std::exception& e) {
70184       {
70185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70186       };
70187     } catch (Dali::DaliException e) {
70188       {
70189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70190       };
70191     } catch (...) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70194       };
70195     }
70196   }
70197
70198   jresult = (void *)result;
70199   return jresult;
70200 }
70201
70202
70203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70204   void * jresult ;
70205   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70206   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70207   Dali::Toolkit::CheckBoxButton *result = 0 ;
70208
70209   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70210   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70211   if (!arg2) {
70212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70213     return 0;
70214   }
70215   {
70216     try {
70217       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70218     } catch (std::out_of_range& e) {
70219       {
70220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70221       };
70222     } catch (std::exception& e) {
70223       {
70224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (Dali::DaliException e) {
70227       {
70228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70229       };
70230     } catch (...) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70233       };
70234     }
70235   }
70236
70237   jresult = (void *)result;
70238   return jresult;
70239 }
70240
70241
70242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70243   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70244
70245   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70246   {
70247     try {
70248       delete arg1;
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (Dali::DaliException e) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70264       };
70265     }
70266   }
70267
70268 }
70269
70270
70271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70272   void * jresult ;
70273   Dali::Toolkit::CheckBoxButton result;
70274
70275   {
70276     try {
70277       result = Dali::Toolkit::CheckBoxButton::New();
70278     } catch (std::out_of_range& e) {
70279       {
70280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (std::exception& e) {
70283       {
70284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (Dali::DaliException e) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70289       };
70290     } catch (...) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70293       };
70294     }
70295   }
70296
70297   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70298   return jresult;
70299 }
70300
70301
70302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70303   void * jresult ;
70304   Dali::BaseHandle arg1 ;
70305   Dali::BaseHandle *argp1 ;
70306   Dali::Toolkit::CheckBoxButton result;
70307
70308   argp1 = (Dali::BaseHandle *)jarg1;
70309   if (!argp1) {
70310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70311     return 0;
70312   }
70313   arg1 = *argp1;
70314   {
70315     try {
70316       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70317     } catch (std::out_of_range& e) {
70318       {
70319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (std::exception& e) {
70322       {
70323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70324       };
70325     } catch (Dali::DaliException e) {
70326       {
70327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70328       };
70329     } catch (...) {
70330       {
70331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70332       };
70333     }
70334   }
70335
70336   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70337   return jresult;
70338 }
70339
70340
70341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70342   int jresult ;
70343   int result;
70344
70345   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70346   jresult = (int)result;
70347   return jresult;
70348 }
70349
70350
70351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70352   int jresult ;
70353   int result;
70354
70355   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70356   jresult = (int)result;
70357   return jresult;
70358 }
70359
70360
70361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70362   int jresult ;
70363   int result;
70364
70365   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70366   jresult = (int)result;
70367   return jresult;
70368 }
70369
70370
70371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70372   int jresult ;
70373   int result;
70374
70375   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70376   jresult = (int)result;
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70382   int jresult ;
70383   int result;
70384
70385   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70386   jresult = (int)result;
70387   return jresult;
70388 }
70389
70390
70391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70392   void * jresult ;
70393   Dali::Toolkit::PushButton::Property *result = 0 ;
70394
70395   {
70396     try {
70397       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70398     } catch (std::out_of_range& e) {
70399       {
70400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70401       };
70402     } catch (std::exception& e) {
70403       {
70404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70405       };
70406     } catch (Dali::DaliException e) {
70407       {
70408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70409       };
70410     } catch (...) {
70411       {
70412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70413       };
70414     }
70415   }
70416
70417   jresult = (void *)result;
70418   return jresult;
70419 }
70420
70421
70422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70423   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70424
70425   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70426   {
70427     try {
70428       delete arg1;
70429     } catch (std::out_of_range& e) {
70430       {
70431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70432       };
70433     } catch (std::exception& e) {
70434       {
70435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70436       };
70437     } catch (Dali::DaliException e) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70444       };
70445     }
70446   }
70447
70448 }
70449
70450
70451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70452   void * jresult ;
70453   Dali::Toolkit::PushButton *result = 0 ;
70454
70455   {
70456     try {
70457       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70473       };
70474     }
70475   }
70476
70477   jresult = (void *)result;
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70483   void * jresult ;
70484   Dali::Toolkit::PushButton *arg1 = 0 ;
70485   Dali::Toolkit::PushButton *result = 0 ;
70486
70487   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70488   if (!arg1) {
70489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70490     return 0;
70491   }
70492   {
70493     try {
70494       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
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 = (void *)result;
70515   return jresult;
70516 }
70517
70518
70519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70520   void * jresult ;
70521   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70522   Dali::Toolkit::PushButton *arg2 = 0 ;
70523   Dali::Toolkit::PushButton *result = 0 ;
70524
70525   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70526   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70527   if (!arg2) {
70528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70529     return 0;
70530   }
70531   {
70532     try {
70533       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70534     } catch (std::out_of_range& e) {
70535       {
70536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70537       };
70538     } catch (std::exception& e) {
70539       {
70540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70541       };
70542     } catch (Dali::DaliException e) {
70543       {
70544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70545       };
70546     } catch (...) {
70547       {
70548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70549       };
70550     }
70551   }
70552
70553   jresult = (void *)result;
70554   return jresult;
70555 }
70556
70557
70558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70559   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70560
70561   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70562   {
70563     try {
70564       delete arg1;
70565     } catch (std::out_of_range& e) {
70566       {
70567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (std::exception& e) {
70570       {
70571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (Dali::DaliException e) {
70574       {
70575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70576       };
70577     } catch (...) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70580       };
70581     }
70582   }
70583
70584 }
70585
70586
70587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70588   void * jresult ;
70589   Dali::Toolkit::PushButton result;
70590
70591   {
70592     try {
70593       result = Dali::Toolkit::PushButton::New();
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 = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70614   return jresult;
70615 }
70616
70617
70618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70619   void * jresult ;
70620   Dali::BaseHandle arg1 ;
70621   Dali::BaseHandle *argp1 ;
70622   Dali::Toolkit::PushButton result;
70623
70624   argp1 = (Dali::BaseHandle *)jarg1;
70625   if (!argp1) {
70626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70627     return 0;
70628   }
70629   arg1 = *argp1;
70630   {
70631     try {
70632       result = Dali::Toolkit::PushButton::DownCast(arg1);
70633     } catch (std::out_of_range& e) {
70634       {
70635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70636       };
70637     } catch (std::exception& e) {
70638       {
70639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70640       };
70641     } catch (Dali::DaliException e) {
70642       {
70643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70644       };
70645     } catch (...) {
70646       {
70647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70648       };
70649     }
70650   }
70651
70652   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70653   return jresult;
70654 }
70655
70656
70657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70658   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70659   Dali::Image arg2 ;
70660   Dali::Image *argp2 ;
70661
70662   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70663   argp2 = (Dali::Image *)jarg2;
70664   if (!argp2) {
70665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70666     return ;
70667   }
70668   arg2 = *argp2;
70669   {
70670     try {
70671       (arg1)->SetButtonImage(arg2);
70672     } catch (std::out_of_range& e) {
70673       {
70674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70675       };
70676     } catch (std::exception& e) {
70677       {
70678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70679       };
70680     } catch (Dali::DaliException e) {
70681       {
70682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70683       };
70684     } catch (...) {
70685       {
70686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70687       };
70688     }
70689   }
70690
70691 }
70692
70693
70694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70695   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70696   Dali::Actor arg2 ;
70697   Dali::Actor *argp2 ;
70698
70699   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70700   argp2 = (Dali::Actor *)jarg2;
70701   if (!argp2) {
70702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70703     return ;
70704   }
70705   arg2 = *argp2;
70706   {
70707     try {
70708       (arg1)->SetButtonImage(arg2);
70709     } catch (std::out_of_range& e) {
70710       {
70711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70712       };
70713     } catch (std::exception& e) {
70714       {
70715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70716       };
70717     } catch (Dali::DaliException e) {
70718       {
70719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70720       };
70721     } catch (...) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70724       };
70725     }
70726   }
70727
70728 }
70729
70730
70731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70732   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70733   Dali::Actor arg2 ;
70734   Dali::Actor *argp2 ;
70735
70736   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70737   argp2 = (Dali::Actor *)jarg2;
70738   if (!argp2) {
70739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70740     return ;
70741   }
70742   arg2 = *argp2;
70743   {
70744     try {
70745       (arg1)->SetBackgroundImage(arg2);
70746     } catch (std::out_of_range& e) {
70747       {
70748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70749       };
70750     } catch (std::exception& e) {
70751       {
70752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70753       };
70754     } catch (Dali::DaliException e) {
70755       {
70756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70757       };
70758     } catch (...) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70761       };
70762     }
70763   }
70764
70765 }
70766
70767
70768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70769   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70770   Dali::Image arg2 ;
70771   Dali::Image *argp2 ;
70772
70773   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70774   argp2 = (Dali::Image *)jarg2;
70775   if (!argp2) {
70776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70777     return ;
70778   }
70779   arg2 = *argp2;
70780   {
70781     try {
70782       (arg1)->SetSelectedImage(arg2);
70783     } catch (std::out_of_range& e) {
70784       {
70785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (std::exception& e) {
70788       {
70789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70790       };
70791     } catch (Dali::DaliException e) {
70792       {
70793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70794       };
70795     } catch (...) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70798       };
70799     }
70800   }
70801
70802 }
70803
70804
70805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70806   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70807   Dali::Actor arg2 ;
70808   Dali::Actor *argp2 ;
70809
70810   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70811   argp2 = (Dali::Actor *)jarg2;
70812   if (!argp2) {
70813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70814     return ;
70815   }
70816   arg2 = *argp2;
70817   {
70818     try {
70819       (arg1)->SetSelectedImage(arg2);
70820     } catch (std::out_of_range& e) {
70821       {
70822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70823       };
70824     } catch (std::exception& e) {
70825       {
70826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70827       };
70828     } catch (Dali::DaliException e) {
70829       {
70830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70831       };
70832     } catch (...) {
70833       {
70834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70835       };
70836     }
70837   }
70838
70839 }
70840
70841
70842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70843   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70844   Dali::Actor arg2 ;
70845   Dali::Actor *argp2 ;
70846
70847   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70848   argp2 = (Dali::Actor *)jarg2;
70849   if (!argp2) {
70850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70851     return ;
70852   }
70853   arg2 = *argp2;
70854   {
70855     try {
70856       (arg1)->SetSelectedBackgroundImage(arg2);
70857     } catch (std::out_of_range& e) {
70858       {
70859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70860       };
70861     } catch (std::exception& e) {
70862       {
70863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70864       };
70865     } catch (Dali::DaliException e) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70868       };
70869     } catch (...) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70872       };
70873     }
70874   }
70875
70876 }
70877
70878
70879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70880   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70881   Dali::Actor arg2 ;
70882   Dali::Actor *argp2 ;
70883
70884   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70885   argp2 = (Dali::Actor *)jarg2;
70886   if (!argp2) {
70887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70888     return ;
70889   }
70890   arg2 = *argp2;
70891   {
70892     try {
70893       (arg1)->SetDisabledBackgroundImage(arg2);
70894     } catch (std::out_of_range& e) {
70895       {
70896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70897       };
70898     } catch (std::exception& e) {
70899       {
70900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70901       };
70902     } catch (Dali::DaliException e) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70905       };
70906     } catch (...) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70909       };
70910     }
70911   }
70912
70913 }
70914
70915
70916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70917   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70918   Dali::Actor arg2 ;
70919   Dali::Actor *argp2 ;
70920
70921   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70922   argp2 = (Dali::Actor *)jarg2;
70923   if (!argp2) {
70924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70925     return ;
70926   }
70927   arg2 = *argp2;
70928   {
70929     try {
70930       (arg1)->SetDisabledImage(arg2);
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_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70954   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70955   Dali::Actor arg2 ;
70956   Dali::Actor *argp2 ;
70957
70958   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70959   argp2 = (Dali::Actor *)jarg2;
70960   if (!argp2) {
70961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70962     return ;
70963   }
70964   arg2 = *argp2;
70965   {
70966     try {
70967       (arg1)->SetDisabledSelectedImage(arg2);
70968     } catch (std::out_of_range& e) {
70969       {
70970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70971       };
70972     } catch (std::exception& e) {
70973       {
70974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (Dali::DaliException e) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70983       };
70984     }
70985   }
70986
70987 }
70988
70989
70990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70991   void * jresult ;
70992   Dali::Toolkit::RadioButton *result = 0 ;
70993
70994   {
70995     try {
70996       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70997     } catch (std::out_of_range& e) {
70998       {
70999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71000       };
71001     } catch (std::exception& e) {
71002       {
71003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71004       };
71005     } catch (Dali::DaliException e) {
71006       {
71007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71008       };
71009     } catch (...) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71012       };
71013     }
71014   }
71015
71016   jresult = (void *)result;
71017   return jresult;
71018 }
71019
71020
71021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71022   void * jresult ;
71023   Dali::Toolkit::RadioButton *arg1 = 0 ;
71024   Dali::Toolkit::RadioButton *result = 0 ;
71025
71026   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71027   if (!arg1) {
71028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71029     return 0;
71030   }
71031   {
71032     try {
71033       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71034     } catch (std::out_of_range& e) {
71035       {
71036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71037       };
71038     } catch (std::exception& e) {
71039       {
71040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (Dali::DaliException e) {
71043       {
71044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71045       };
71046     } catch (...) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71049       };
71050     }
71051   }
71052
71053   jresult = (void *)result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71059   void * jresult ;
71060   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71061   Dali::Toolkit::RadioButton *arg2 = 0 ;
71062   Dali::Toolkit::RadioButton *result = 0 ;
71063
71064   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71065   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71066   if (!arg2) {
71067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71068     return 0;
71069   }
71070   {
71071     try {
71072       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71073     } catch (std::out_of_range& e) {
71074       {
71075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71076       };
71077     } catch (std::exception& e) {
71078       {
71079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (Dali::DaliException e) {
71082       {
71083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71084       };
71085     } catch (...) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71088       };
71089     }
71090   }
71091
71092   jresult = (void *)result;
71093   return jresult;
71094 }
71095
71096
71097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71098   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71099
71100   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71101   {
71102     try {
71103       delete arg1;
71104     } catch (std::out_of_range& e) {
71105       {
71106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (std::exception& e) {
71109       {
71110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71111       };
71112     } catch (Dali::DaliException e) {
71113       {
71114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71115       };
71116     } catch (...) {
71117       {
71118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71119       };
71120     }
71121   }
71122
71123 }
71124
71125
71126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71127   void * jresult ;
71128   Dali::Toolkit::RadioButton result;
71129
71130   {
71131     try {
71132       result = Dali::Toolkit::RadioButton::New();
71133     } catch (std::out_of_range& e) {
71134       {
71135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (std::exception& e) {
71138       {
71139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (Dali::DaliException e) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71144       };
71145     } catch (...) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71148       };
71149     }
71150   }
71151
71152   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71158   void * jresult ;
71159   std::string *arg1 = 0 ;
71160   Dali::Toolkit::RadioButton result;
71161
71162   if (!jarg1) {
71163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71164     return 0;
71165   }
71166   std::string arg1_str(jarg1);
71167   arg1 = &arg1_str;
71168   {
71169     try {
71170       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71171     } catch (std::out_of_range& e) {
71172       {
71173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (std::exception& e) {
71176       {
71177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (Dali::DaliException e) {
71180       {
71181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71182       };
71183     } catch (...) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71186       };
71187     }
71188   }
71189
71190   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71191
71192   //argout typemap for const std::string&
71193
71194   return jresult;
71195 }
71196
71197
71198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71199   void * jresult ;
71200   Dali::BaseHandle arg1 ;
71201   Dali::BaseHandle *argp1 ;
71202   Dali::Toolkit::RadioButton result;
71203
71204   argp1 = (Dali::BaseHandle *)jarg1;
71205   if (!argp1) {
71206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71207     return 0;
71208   }
71209   arg1 = *argp1;
71210   {
71211     try {
71212       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71213     } catch (std::out_of_range& e) {
71214       {
71215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71216       };
71217     } catch (std::exception& e) {
71218       {
71219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (Dali::DaliException e) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71224       };
71225     } catch (...) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71228       };
71229     }
71230   }
71231
71232   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71238   int jresult ;
71239   int result;
71240
71241   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71242   jresult = (int)result;
71243   return jresult;
71244 }
71245
71246
71247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71248   int jresult ;
71249   int result;
71250
71251   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71252   jresult = (int)result;
71253   return jresult;
71254 }
71255
71256
71257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71258   int jresult ;
71259   int result;
71260
71261   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71262   jresult = (int)result;
71263   return jresult;
71264 }
71265
71266
71267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71268   int jresult ;
71269   int result;
71270
71271   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71272   jresult = (int)result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71278   int jresult ;
71279   int result;
71280
71281   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71282   jresult = (int)result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71288   int jresult ;
71289   int result;
71290
71291   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71292   jresult = (int)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71298   void * jresult ;
71299   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71300
71301   {
71302     try {
71303       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71304     } catch (std::out_of_range& e) {
71305       {
71306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71307       };
71308     } catch (std::exception& e) {
71309       {
71310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71311       };
71312     } catch (Dali::DaliException e) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71315       };
71316     } catch (...) {
71317       {
71318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71319       };
71320     }
71321   }
71322
71323   jresult = (void *)result;
71324   return jresult;
71325 }
71326
71327
71328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71329   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71330
71331   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71332   {
71333     try {
71334       delete arg1;
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71342       };
71343     } catch (Dali::DaliException e) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71346       };
71347     } catch (...) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71350       };
71351     }
71352   }
71353
71354 }
71355
71356
71357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71358   int jresult ;
71359   int result;
71360
71361   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71362   jresult = (int)result;
71363   return jresult;
71364 }
71365
71366
71367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71368   int jresult ;
71369   int result;
71370
71371   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71372   jresult = (int)result;
71373   return jresult;
71374 }
71375
71376
71377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71378   int jresult ;
71379   int result;
71380
71381   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71382   jresult = (int)result;
71383   return jresult;
71384 }
71385
71386
71387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71388   void * jresult ;
71389   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71390
71391   {
71392     try {
71393       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71394     } catch (std::out_of_range& e) {
71395       {
71396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71397       };
71398     } catch (std::exception& e) {
71399       {
71400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71401       };
71402     } catch (Dali::DaliException e) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71405       };
71406     } catch (...) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71409       };
71410     }
71411   }
71412
71413   jresult = (void *)result;
71414   return jresult;
71415 }
71416
71417
71418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71419   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71420
71421   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71422   {
71423     try {
71424       delete arg1;
71425     } catch (std::out_of_range& e) {
71426       {
71427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71428       };
71429     } catch (std::exception& e) {
71430       {
71431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (Dali::DaliException e) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71436       };
71437     } catch (...) {
71438       {
71439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71440       };
71441     }
71442   }
71443
71444 }
71445
71446
71447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71448   void * jresult ;
71449   Dali::Toolkit::FlexContainer *result = 0 ;
71450
71451   {
71452     try {
71453       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71454     } catch (std::out_of_range& e) {
71455       {
71456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71457       };
71458     } catch (std::exception& e) {
71459       {
71460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (Dali::DaliException e) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71465       };
71466     } catch (...) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71469       };
71470     }
71471   }
71472
71473   jresult = (void *)result;
71474   return jresult;
71475 }
71476
71477
71478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71479   void * jresult ;
71480   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71481   Dali::Toolkit::FlexContainer *result = 0 ;
71482
71483   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71484   if (!arg1) {
71485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71486     return 0;
71487   }
71488   {
71489     try {
71490       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71491     } catch (std::out_of_range& e) {
71492       {
71493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (std::exception& e) {
71496       {
71497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71498       };
71499     } catch (Dali::DaliException e) {
71500       {
71501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71502       };
71503     } catch (...) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71506       };
71507     }
71508   }
71509
71510   jresult = (void *)result;
71511   return jresult;
71512 }
71513
71514
71515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71516   void * jresult ;
71517   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71518   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71519   Dali::Toolkit::FlexContainer *result = 0 ;
71520
71521   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71522   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71523   if (!arg2) {
71524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71525     return 0;
71526   }
71527   {
71528     try {
71529       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71530     } catch (std::out_of_range& e) {
71531       {
71532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71533       };
71534     } catch (std::exception& e) {
71535       {
71536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (Dali::DaliException e) {
71539       {
71540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71545       };
71546     }
71547   }
71548
71549   jresult = (void *)result;
71550   return jresult;
71551 }
71552
71553
71554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71555   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71556
71557   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71558   {
71559     try {
71560       delete arg1;
71561     } catch (std::out_of_range& e) {
71562       {
71563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71564       };
71565     } catch (std::exception& e) {
71566       {
71567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71568       };
71569     } catch (Dali::DaliException e) {
71570       {
71571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71572       };
71573     } catch (...) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71576       };
71577     }
71578   }
71579
71580 }
71581
71582
71583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71584   void * jresult ;
71585   Dali::Toolkit::FlexContainer result;
71586
71587   {
71588     try {
71589       result = Dali::Toolkit::FlexContainer::New();
71590     } catch (std::out_of_range& e) {
71591       {
71592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71593       };
71594     } catch (std::exception& e) {
71595       {
71596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71597       };
71598     } catch (Dali::DaliException e) {
71599       {
71600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71601       };
71602     } catch (...) {
71603       {
71604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71605       };
71606     }
71607   }
71608
71609   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71610   return jresult;
71611 }
71612
71613
71614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71615   void * jresult ;
71616   Dali::BaseHandle arg1 ;
71617   Dali::BaseHandle *argp1 ;
71618   Dali::Toolkit::FlexContainer result;
71619
71620   argp1 = (Dali::BaseHandle *)jarg1;
71621   if (!argp1) {
71622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71623     return 0;
71624   }
71625   arg1 = *argp1;
71626   {
71627     try {
71628       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71629     } catch (std::out_of_range& e) {
71630       {
71631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71632       };
71633     } catch (std::exception& e) {
71634       {
71635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (Dali::DaliException e) {
71638       {
71639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71640       };
71641     } catch (...) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71644       };
71645     }
71646   }
71647
71648   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71649   return jresult;
71650 }
71651
71652
71653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71654   int jresult ;
71655   int result;
71656
71657   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71658   jresult = (int)result;
71659   return jresult;
71660 }
71661
71662
71663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71664   int jresult ;
71665   int result;
71666
71667   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71668   jresult = (int)result;
71669   return jresult;
71670 }
71671
71672
71673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71674   int jresult ;
71675   int result;
71676
71677   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71678   jresult = (int)result;
71679   return jresult;
71680 }
71681
71682
71683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71684   int jresult ;
71685   int result;
71686
71687   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71688   jresult = (int)result;
71689   return jresult;
71690 }
71691
71692
71693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71694   void * jresult ;
71695   Dali::Toolkit::ImageView::Property *result = 0 ;
71696
71697   {
71698     try {
71699       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (Dali::DaliException e) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71715       };
71716     }
71717   }
71718
71719   jresult = (void *)result;
71720   return jresult;
71721 }
71722
71723
71724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71725   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71726
71727   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71728   {
71729     try {
71730       delete arg1;
71731     } catch (std::out_of_range& e) {
71732       {
71733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71734       };
71735     } catch (std::exception& e) {
71736       {
71737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71738       };
71739     } catch (Dali::DaliException e) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71742       };
71743     } catch (...) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71746       };
71747     }
71748   }
71749
71750 }
71751
71752
71753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71754   void * jresult ;
71755   Dali::Toolkit::ImageView *result = 0 ;
71756
71757   {
71758     try {
71759       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71760     } catch (std::out_of_range& e) {
71761       {
71762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71763       };
71764     } catch (std::exception& e) {
71765       {
71766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71767       };
71768     } catch (Dali::DaliException e) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71771       };
71772     } catch (...) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71775       };
71776     }
71777   }
71778
71779   jresult = (void *)result;
71780   return jresult;
71781 }
71782
71783
71784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71785   void * jresult ;
71786   Dali::Toolkit::ImageView result;
71787
71788   {
71789     try {
71790       result = Dali::Toolkit::ImageView::New();
71791     } catch (std::out_of_range& e) {
71792       {
71793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (std::exception& e) {
71796       {
71797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (Dali::DaliException e) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71802       };
71803     } catch (...) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71806       };
71807     }
71808   }
71809
71810   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71811   return jresult;
71812 }
71813
71814
71815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71816   void * jresult ;
71817   Dali::Image arg1 ;
71818   Dali::Image *argp1 ;
71819   Dali::Toolkit::ImageView result;
71820
71821   argp1 = (Dali::Image *)jarg1;
71822   if (!argp1) {
71823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71824     return 0;
71825   }
71826   arg1 = *argp1;
71827   {
71828     try {
71829       result = Dali::Toolkit::ImageView::New(arg1);
71830     } catch (std::out_of_range& e) {
71831       {
71832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71833       };
71834     } catch (std::exception& e) {
71835       {
71836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71837       };
71838     } catch (Dali::DaliException e) {
71839       {
71840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71841       };
71842     } catch (...) {
71843       {
71844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71845       };
71846     }
71847   }
71848
71849   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71850   return jresult;
71851 }
71852
71853
71854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71855   void * jresult ;
71856   std::string *arg1 = 0 ;
71857   Dali::Toolkit::ImageView result;
71858
71859   if (!jarg1) {
71860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71861     return 0;
71862   }
71863   std::string arg1_str(jarg1);
71864   arg1 = &arg1_str;
71865   {
71866     try {
71867       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71868     } catch (std::out_of_range& e) {
71869       {
71870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71871       };
71872     } catch (std::exception& e) {
71873       {
71874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71875       };
71876     } catch (Dali::DaliException e) {
71877       {
71878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71879       };
71880     } catch (...) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71883       };
71884     }
71885   }
71886
71887   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71888
71889   //argout typemap for const std::string&
71890
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71896   void * jresult ;
71897   std::string *arg1 = 0 ;
71898   Dali::ImageDimensions arg2 ;
71899   Dali::ImageDimensions *argp2 ;
71900   Dali::Toolkit::ImageView result;
71901
71902   if (!jarg1) {
71903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71904     return 0;
71905   }
71906   std::string arg1_str(jarg1);
71907   arg1 = &arg1_str;
71908   argp2 = (Dali::ImageDimensions *)jarg2;
71909   if (!argp2) {
71910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71911     return 0;
71912   }
71913   arg2 = *argp2;
71914   {
71915     try {
71916       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71917     } catch (std::out_of_range& e) {
71918       {
71919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71920       };
71921     } catch (std::exception& e) {
71922       {
71923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (Dali::DaliException e) {
71926       {
71927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71928       };
71929     } catch (...) {
71930       {
71931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71932       };
71933     }
71934   }
71935
71936   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71937
71938   //argout typemap for const std::string&
71939
71940   return jresult;
71941 }
71942
71943
71944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71945   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71946
71947   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71948   {
71949     try {
71950       delete arg1;
71951     } catch (std::out_of_range& e) {
71952       {
71953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71954       };
71955     } catch (std::exception& e) {
71956       {
71957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (Dali::DaliException e) {
71960       {
71961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71966       };
71967     }
71968   }
71969
71970 }
71971
71972
71973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71974   void * jresult ;
71975   Dali::Toolkit::ImageView *arg1 = 0 ;
71976   Dali::Toolkit::ImageView *result = 0 ;
71977
71978   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71979   if (!arg1) {
71980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71981     return 0;
71982   }
71983   {
71984     try {
71985       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
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 = (void *)result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72011   void * jresult ;
72012   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72013   Dali::Toolkit::ImageView *arg2 = 0 ;
72014   Dali::Toolkit::ImageView *result = 0 ;
72015
72016   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72017   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72018   if (!arg2) {
72019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72020     return 0;
72021   }
72022   {
72023     try {
72024       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72025     } catch (std::out_of_range& e) {
72026       {
72027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72028       };
72029     } catch (std::exception& e) {
72030       {
72031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72032       };
72033     } catch (Dali::DaliException e) {
72034       {
72035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72036       };
72037     } catch (...) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72040       };
72041     }
72042   }
72043
72044   jresult = (void *)result;
72045   return jresult;
72046 }
72047
72048
72049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72050   void * jresult ;
72051   Dali::BaseHandle arg1 ;
72052   Dali::BaseHandle *argp1 ;
72053   Dali::Toolkit::ImageView result;
72054
72055   argp1 = (Dali::BaseHandle *)jarg1;
72056   if (!argp1) {
72057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72058     return 0;
72059   }
72060   arg1 = *argp1;
72061   {
72062     try {
72063       result = Dali::Toolkit::ImageView::DownCast(arg1);
72064     } catch (std::out_of_range& e) {
72065       {
72066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72067       };
72068     } catch (std::exception& e) {
72069       {
72070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72071       };
72072     } catch (Dali::DaliException e) {
72073       {
72074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72075       };
72076     } catch (...) {
72077       {
72078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72079       };
72080     }
72081   }
72082
72083   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72084   return jresult;
72085 }
72086
72087
72088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72089   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72090   Dali::Image arg2 ;
72091   Dali::Image *argp2 ;
72092
72093   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72094   argp2 = (Dali::Image *)jarg2;
72095   if (!argp2) {
72096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72097     return ;
72098   }
72099   arg2 = *argp2;
72100   {
72101     try {
72102       (arg1)->SetImage(arg2);
72103     } catch (std::out_of_range& e) {
72104       {
72105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72106       };
72107     } catch (std::exception& e) {
72108       {
72109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72110       };
72111     } catch (Dali::DaliException e) {
72112       {
72113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72114       };
72115     } catch (...) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72118       };
72119     }
72120   }
72121
72122 }
72123
72124
72125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72126   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72127   std::string *arg2 = 0 ;
72128
72129   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72130   if (!jarg2) {
72131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72132     return ;
72133   }
72134   std::string arg2_str(jarg2);
72135   arg2 = &arg2_str;
72136   {
72137     try {
72138       (arg1)->SetImage((std::string const &)*arg2);
72139     } catch (std::out_of_range& e) {
72140       {
72141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72142       };
72143     } catch (std::exception& e) {
72144       {
72145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72146       };
72147     } catch (Dali::DaliException e) {
72148       {
72149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72150       };
72151     } catch (...) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72154       };
72155     }
72156   }
72157
72158
72159   //argout typemap for const std::string&
72160
72161 }
72162
72163
72164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72165   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72166   std::string *arg2 = 0 ;
72167   Dali::ImageDimensions arg3 ;
72168   Dali::ImageDimensions *argp3 ;
72169
72170   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72171   if (!jarg2) {
72172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72173     return ;
72174   }
72175   std::string arg2_str(jarg2);
72176   arg2 = &arg2_str;
72177   argp3 = (Dali::ImageDimensions *)jarg3;
72178   if (!argp3) {
72179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72180     return ;
72181   }
72182   arg3 = *argp3;
72183   {
72184     try {
72185       (arg1)->SetImage((std::string const &)*arg2,arg3);
72186     } catch (std::out_of_range& e) {
72187       {
72188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72189       };
72190     } catch (std::exception& e) {
72191       {
72192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72193       };
72194     } catch (Dali::DaliException e) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72197       };
72198     } catch (...) {
72199       {
72200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72201       };
72202     }
72203   }
72204
72205
72206   //argout typemap for const std::string&
72207
72208 }
72209
72210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72211   void * jresult ;
72212   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72213   Dali::Image result;
72214
72215   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72216   {
72217     try {
72218       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72219     } catch (std::out_of_range& e) {
72220       {
72221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72222       };
72223     } catch (std::exception& e) {
72224       {
72225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (Dali::DaliException e) {
72228       {
72229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72230       };
72231     } catch (...) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72234       };
72235     }
72236   }
72237
72238   jresult = new Dali::Image((const Dali::Image &)result);
72239   return jresult;
72240 }
72241
72242
72243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72244   int jresult ;
72245   int result;
72246
72247   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72248   jresult = (int)result;
72249   return jresult;
72250 }
72251
72252
72253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72254   int jresult ;
72255   int result;
72256
72257   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72258   jresult = (int)result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72264   int jresult ;
72265   int result;
72266
72267   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72268   jresult = (int)result;
72269   return jresult;
72270 }
72271
72272
72273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72274   int jresult ;
72275   int result;
72276
72277   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72278   jresult = (int)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72284   int jresult ;
72285   int result;
72286
72287   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72288   jresult = (int)result;
72289   return jresult;
72290 }
72291
72292
72293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72294   int jresult ;
72295   int result;
72296
72297   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72298   jresult = (int)result;
72299   return jresult;
72300 }
72301
72302
72303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72304   int jresult ;
72305   int result;
72306
72307   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72308   jresult = (int)result;
72309   return jresult;
72310 }
72311
72312
72313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72314   int jresult ;
72315   int result;
72316
72317   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72318   jresult = (int)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72324   void * jresult ;
72325   Dali::Toolkit::Model3dView::Property *result = 0 ;
72326
72327   {
72328     try {
72329       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72345       };
72346     }
72347   }
72348
72349   jresult = (void *)result;
72350   return jresult;
72351 }
72352
72353
72354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72355   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72356
72357   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72358   {
72359     try {
72360       delete arg1;
72361     } catch (std::out_of_range& e) {
72362       {
72363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72364       };
72365     } catch (std::exception& e) {
72366       {
72367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72368       };
72369     } catch (Dali::DaliException e) {
72370       {
72371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72372       };
72373     } catch (...) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72376       };
72377     }
72378   }
72379
72380 }
72381
72382
72383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72384   void * jresult ;
72385   Dali::Toolkit::Model3dView result;
72386
72387   {
72388     try {
72389       result = Dali::Toolkit::Model3dView::New();
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (Dali::DaliException e) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72401       };
72402     } catch (...) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72405       };
72406     }
72407   }
72408
72409   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72410   return jresult;
72411 }
72412
72413
72414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72415   void * jresult ;
72416   std::string *arg1 = 0 ;
72417   std::string *arg2 = 0 ;
72418   std::string *arg3 = 0 ;
72419   Dali::Toolkit::Model3dView result;
72420
72421   if (!jarg1) {
72422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72423     return 0;
72424   }
72425   std::string arg1_str(jarg1);
72426   arg1 = &arg1_str;
72427   if (!jarg2) {
72428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72429     return 0;
72430   }
72431   std::string arg2_str(jarg2);
72432   arg2 = &arg2_str;
72433   if (!jarg3) {
72434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72435     return 0;
72436   }
72437   std::string arg3_str(jarg3);
72438   arg3 = &arg3_str;
72439   {
72440     try {
72441       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72442     } catch (std::out_of_range& e) {
72443       {
72444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72445       };
72446     } catch (std::exception& e) {
72447       {
72448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72449       };
72450     } catch (Dali::DaliException e) {
72451       {
72452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72453       };
72454     } catch (...) {
72455       {
72456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72457       };
72458     }
72459   }
72460
72461   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72462
72463   //argout typemap for const std::string&
72464
72465
72466   //argout typemap for const std::string&
72467
72468
72469   //argout typemap for const std::string&
72470
72471   return jresult;
72472 }
72473
72474
72475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72476   void * jresult ;
72477   Dali::Toolkit::Model3dView *result = 0 ;
72478
72479   {
72480     try {
72481       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72482     } catch (std::out_of_range& e) {
72483       {
72484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72485       };
72486     } catch (std::exception& e) {
72487       {
72488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (Dali::DaliException e) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72493       };
72494     } catch (...) {
72495       {
72496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72497       };
72498     }
72499   }
72500
72501   jresult = (void *)result;
72502   return jresult;
72503 }
72504
72505
72506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72507   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72508
72509   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72510   {
72511     try {
72512       delete arg1;
72513     } catch (std::out_of_range& e) {
72514       {
72515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72516       };
72517     } catch (std::exception& e) {
72518       {
72519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72520       };
72521     } catch (Dali::DaliException e) {
72522       {
72523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72524       };
72525     } catch (...) {
72526       {
72527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72528       };
72529     }
72530   }
72531
72532 }
72533
72534
72535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72536   void * jresult ;
72537   Dali::Toolkit::Model3dView *arg1 = 0 ;
72538   Dali::Toolkit::Model3dView *result = 0 ;
72539
72540   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72541   if (!arg1) {
72542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72543     return 0;
72544   }
72545   {
72546     try {
72547       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72548     } catch (std::out_of_range& e) {
72549       {
72550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (std::exception& e) {
72553       {
72554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72555       };
72556     } catch (Dali::DaliException e) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72559       };
72560     } catch (...) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72563       };
72564     }
72565   }
72566
72567   jresult = (void *)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72573   void * jresult ;
72574   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72575   Dali::Toolkit::Model3dView *arg2 = 0 ;
72576   Dali::Toolkit::Model3dView *result = 0 ;
72577
72578   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72579   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72580   if (!arg2) {
72581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72582     return 0;
72583   }
72584   {
72585     try {
72586       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72587     } catch (std::out_of_range& e) {
72588       {
72589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72590       };
72591     } catch (std::exception& e) {
72592       {
72593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (Dali::DaliException e) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72598       };
72599     } catch (...) {
72600       {
72601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72602       };
72603     }
72604   }
72605
72606   jresult = (void *)result;
72607   return jresult;
72608 }
72609
72610
72611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72612   void * jresult ;
72613   Dali::BaseHandle arg1 ;
72614   Dali::BaseHandle *argp1 ;
72615   Dali::Toolkit::Model3dView result;
72616
72617   argp1 = (Dali::BaseHandle *)jarg1;
72618   if (!argp1) {
72619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72620     return 0;
72621   }
72622   arg1 = *argp1;
72623   {
72624     try {
72625       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72626     } catch (std::out_of_range& e) {
72627       {
72628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72629       };
72630     } catch (std::exception& e) {
72631       {
72632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72633       };
72634     } catch (Dali::DaliException e) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72637       };
72638     } catch (...) {
72639       {
72640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72641       };
72642     }
72643   }
72644
72645   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72646   return jresult;
72647 }
72648
72649
72650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72651   int jresult ;
72652   int result;
72653
72654   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72655   jresult = (int)result;
72656   return jresult;
72657 }
72658
72659
72660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72661   int jresult ;
72662   int result;
72663
72664   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72665   jresult = (int)result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72671   int jresult ;
72672   int result;
72673
72674   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72675   jresult = (int)result;
72676   return jresult;
72677 }
72678
72679
72680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72681   int jresult ;
72682   int result;
72683
72684   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72685   jresult = (int)result;
72686   return jresult;
72687 }
72688
72689
72690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72691   int jresult ;
72692   int result;
72693
72694   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72695   jresult = (int)result;
72696   return jresult;
72697 }
72698
72699
72700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72701   int jresult ;
72702   int result;
72703
72704   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72705   jresult = (int)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72711   int jresult ;
72712   int result;
72713
72714   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72715   jresult = (int)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72741   void * jresult ;
72742   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72743
72744   {
72745     try {
72746       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72747     } catch (std::out_of_range& e) {
72748       {
72749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72750       };
72751     } catch (std::exception& e) {
72752       {
72753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (Dali::DaliException e) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72758       };
72759     } catch (...) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72762       };
72763     }
72764   }
72765
72766   jresult = (void *)result;
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72772   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72773
72774   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72775   {
72776     try {
72777       delete arg1;
72778     } catch (std::out_of_range& e) {
72779       {
72780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72781       };
72782     } catch (std::exception& e) {
72783       {
72784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72785       };
72786     } catch (Dali::DaliException e) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72789       };
72790     } catch (...) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72793       };
72794     }
72795   }
72796
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72801   void * jresult ;
72802   Dali::Toolkit::ScrollBar *result = 0 ;
72803
72804   {
72805     try {
72806       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
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 = (void *)result;
72827   return jresult;
72828 }
72829
72830
72831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72832   void * jresult ;
72833   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72834   Dali::Toolkit::ScrollBar *result = 0 ;
72835
72836   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72837   if (!arg1) {
72838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72839     return 0;
72840   }
72841   {
72842     try {
72843       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72844     } catch (std::out_of_range& e) {
72845       {
72846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72847       };
72848     } catch (std::exception& e) {
72849       {
72850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72851       };
72852     } catch (Dali::DaliException e) {
72853       {
72854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72855       };
72856     } catch (...) {
72857       {
72858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72859       };
72860     }
72861   }
72862
72863   jresult = (void *)result;
72864   return jresult;
72865 }
72866
72867
72868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72869   void * jresult ;
72870   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72871   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72872   Dali::Toolkit::ScrollBar *result = 0 ;
72873
72874   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72875   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72876   if (!arg2) {
72877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72878     return 0;
72879   }
72880   {
72881     try {
72882       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72883     } catch (std::out_of_range& e) {
72884       {
72885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72886       };
72887     } catch (std::exception& e) {
72888       {
72889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (Dali::DaliException e) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72898       };
72899     }
72900   }
72901
72902   jresult = (void *)result;
72903   return jresult;
72904 }
72905
72906
72907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72909
72910   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72911   {
72912     try {
72913       delete arg1;
72914     } catch (std::out_of_range& e) {
72915       {
72916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72917       };
72918     } catch (std::exception& e) {
72919       {
72920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72921       };
72922     } catch (Dali::DaliException e) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72925       };
72926     } catch (...) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72929       };
72930     }
72931   }
72932
72933 }
72934
72935
72936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72937   void * jresult ;
72938   Dali::Toolkit::ScrollBar::Direction arg1 ;
72939   Dali::Toolkit::ScrollBar result;
72940
72941   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72942   {
72943     try {
72944       result = Dali::Toolkit::ScrollBar::New(arg1);
72945     } catch (std::out_of_range& e) {
72946       {
72947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72948       };
72949     } catch (std::exception& e) {
72950       {
72951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (Dali::DaliException e) {
72954       {
72955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72956       };
72957     } catch (...) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72960       };
72961     }
72962   }
72963
72964   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72965   return jresult;
72966 }
72967
72968
72969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72970   void * jresult ;
72971   Dali::Toolkit::ScrollBar result;
72972
72973   {
72974     try {
72975       result = Dali::Toolkit::ScrollBar::New();
72976     } catch (std::out_of_range& e) {
72977       {
72978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72979       };
72980     } catch (std::exception& e) {
72981       {
72982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72983       };
72984     } catch (Dali::DaliException e) {
72985       {
72986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72987       };
72988     } catch (...) {
72989       {
72990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72991       };
72992     }
72993   }
72994
72995   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72996   return jresult;
72997 }
72998
72999
73000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73001   void * jresult ;
73002   Dali::BaseHandle arg1 ;
73003   Dali::BaseHandle *argp1 ;
73004   Dali::Toolkit::ScrollBar result;
73005
73006   argp1 = (Dali::BaseHandle *)jarg1;
73007   if (!argp1) {
73008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73009     return 0;
73010   }
73011   arg1 = *argp1;
73012   {
73013     try {
73014       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73015     } catch (std::out_of_range& e) {
73016       {
73017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73018       };
73019     } catch (std::exception& e) {
73020       {
73021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (Dali::DaliException e) {
73024       {
73025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73026       };
73027     } catch (...) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73030       };
73031     }
73032   }
73033
73034   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73035   return jresult;
73036 }
73037
73038
73039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73040   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73041   Dali::Handle arg2 ;
73042   Dali::Property::Index arg3 ;
73043   Dali::Property::Index arg4 ;
73044   Dali::Property::Index arg5 ;
73045   Dali::Property::Index arg6 ;
73046   Dali::Handle *argp2 ;
73047
73048   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73049   argp2 = (Dali::Handle *)jarg2;
73050   if (!argp2) {
73051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73052     return ;
73053   }
73054   arg2 = *argp2;
73055   arg3 = (Dali::Property::Index)jarg3;
73056   arg4 = (Dali::Property::Index)jarg4;
73057   arg5 = (Dali::Property::Index)jarg5;
73058   arg6 = (Dali::Property::Index)jarg6;
73059   {
73060     try {
73061       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73062     } catch (std::out_of_range& e) {
73063       {
73064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73065       };
73066     } catch (std::exception& e) {
73067       {
73068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73069       };
73070     } catch (Dali::DaliException e) {
73071       {
73072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73073       };
73074     } catch (...) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73077       };
73078     }
73079   }
73080
73081 }
73082
73083
73084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73085   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73086   Dali::Actor arg2 ;
73087   Dali::Actor *argp2 ;
73088
73089   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73090   argp2 = (Dali::Actor *)jarg2;
73091   if (!argp2) {
73092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73093     return ;
73094   }
73095   arg2 = *argp2;
73096   {
73097     try {
73098       (arg1)->SetScrollIndicator(arg2);
73099     } catch (std::out_of_range& e) {
73100       {
73101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73102       };
73103     } catch (std::exception& e) {
73104       {
73105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73106       };
73107     } catch (Dali::DaliException e) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73110       };
73111     } catch (...) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73114       };
73115     }
73116   }
73117
73118 }
73119
73120
73121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73122   void * jresult ;
73123   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73124   Dali::Actor result;
73125
73126   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73127   {
73128     try {
73129       result = (arg1)->GetScrollIndicator();
73130     } catch (std::out_of_range& e) {
73131       {
73132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73133       };
73134     } catch (std::exception& e) {
73135       {
73136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73137       };
73138     } catch (Dali::DaliException e) {
73139       {
73140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73141       };
73142     } catch (...) {
73143       {
73144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73145       };
73146     }
73147   }
73148
73149   jresult = new Dali::Actor((const Dali::Actor &)result);
73150   return jresult;
73151 }
73152
73153
73154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73155   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73156   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73157
73158   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73159   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73160   if (!arg2) {
73161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73162     return ;
73163   }
73164   {
73165     try {
73166       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73167     } catch (std::out_of_range& e) {
73168       {
73169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73170       };
73171     } catch (std::exception& e) {
73172       {
73173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73174       };
73175     } catch (Dali::DaliException e) {
73176       {
73177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73178       };
73179     } catch (...) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73182       };
73183     }
73184   }
73185
73186 }
73187
73188
73189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73190   void * jresult ;
73191   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73192
73193   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73194   {
73195     try {
73196       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()));
73197     } catch (std::out_of_range& e) {
73198       {
73199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73200       };
73201     } catch (std::exception& e) {
73202       {
73203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73208       };
73209     }
73210   }
73211   return jresult;
73212 }
73213
73214
73215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73217   Dali::Toolkit::ScrollBar::Direction arg2 ;
73218
73219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73220   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73221   {
73222     try {
73223       (arg1)->SetScrollDirection(arg2);
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73231       };
73232     } catch (Dali::DaliException e) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73239       };
73240     }
73241   }
73242
73243 }
73244
73245
73246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73247   int jresult ;
73248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73249   Dali::Toolkit::ScrollBar::Direction result;
73250
73251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73252   {
73253     try {
73254       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73255     } catch (std::out_of_range& e) {
73256       {
73257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73258       };
73259     } catch (std::exception& e) {
73260       {
73261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (Dali::DaliException e) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73270       };
73271     }
73272   }
73273
73274   jresult = (int)result;
73275   return jresult;
73276 }
73277
73278
73279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73280   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73281   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73282
73283   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73284   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73285   {
73286     try {
73287       (arg1)->SetIndicatorHeightPolicy(arg2);
73288     } catch (std::out_of_range& e) {
73289       {
73290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73291       };
73292     } catch (std::exception& e) {
73293       {
73294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73295       };
73296     } catch (Dali::DaliException e) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73299       };
73300     } catch (...) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73303       };
73304     }
73305   }
73306
73307 }
73308
73309
73310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73311   int jresult ;
73312   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73313   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73314
73315   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73316   {
73317     try {
73318       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73319     } catch (std::out_of_range& e) {
73320       {
73321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (std::exception& e) {
73324       {
73325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (Dali::DaliException e) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73330       };
73331     } catch (...) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73334       };
73335     }
73336   }
73337
73338   jresult = (int)result;
73339   return jresult;
73340 }
73341
73342
73343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73345   float arg2 ;
73346
73347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73348   arg2 = (float)jarg2;
73349   {
73350     try {
73351       (arg1)->SetIndicatorFixedHeight(arg2);
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73359       };
73360     } catch (Dali::DaliException e) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73367       };
73368     }
73369   }
73370
73371 }
73372
73373
73374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73375   float jresult ;
73376   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73377   float result;
73378
73379   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73380   {
73381     try {
73382       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73383     } catch (std::out_of_range& e) {
73384       {
73385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (std::exception& e) {
73388       {
73389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73390       };
73391     } catch (Dali::DaliException e) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73394       };
73395     } catch (...) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73398       };
73399     }
73400   }
73401
73402   jresult = result;
73403   return jresult;
73404 }
73405
73406
73407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73408   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73409   float arg2 ;
73410
73411   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73412   arg2 = (float)jarg2;
73413   {
73414     try {
73415       (arg1)->SetIndicatorShowDuration(arg2);
73416     } catch (std::out_of_range& e) {
73417       {
73418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73419       };
73420     } catch (std::exception& e) {
73421       {
73422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73423       };
73424     } catch (Dali::DaliException e) {
73425       {
73426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73427       };
73428     } catch (...) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73431       };
73432     }
73433   }
73434
73435 }
73436
73437
73438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73439   float jresult ;
73440   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73441   float result;
73442
73443   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73444   {
73445     try {
73446       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73447     } catch (std::out_of_range& e) {
73448       {
73449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73450       };
73451     } catch (std::exception& e) {
73452       {
73453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73454       };
73455     } catch (Dali::DaliException e) {
73456       {
73457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73458       };
73459     } catch (...) {
73460       {
73461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73462       };
73463     }
73464   }
73465
73466   jresult = result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73472   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73473   float arg2 ;
73474
73475   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73476   arg2 = (float)jarg2;
73477   {
73478     try {
73479       (arg1)->SetIndicatorHideDuration(arg2);
73480     } catch (std::out_of_range& e) {
73481       {
73482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73483       };
73484     } catch (std::exception& e) {
73485       {
73486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73487       };
73488     } catch (Dali::DaliException e) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73491       };
73492     } catch (...) {
73493       {
73494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73495       };
73496     }
73497   }
73498
73499 }
73500
73501
73502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73503   float jresult ;
73504   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73505   float result;
73506
73507   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73508   {
73509     try {
73510       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73511     } catch (std::out_of_range& e) {
73512       {
73513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73514       };
73515     } catch (std::exception& e) {
73516       {
73517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (Dali::DaliException e) {
73520       {
73521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73526       };
73527     }
73528   }
73529
73530   jresult = result;
73531   return jresult;
73532 }
73533
73534
73535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73536   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73537
73538   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73539   {
73540     try {
73541       (arg1)->ShowIndicator();
73542     } catch (std::out_of_range& e) {
73543       {
73544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73545       };
73546     } catch (std::exception& e) {
73547       {
73548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73549       };
73550     } catch (Dali::DaliException e) {
73551       {
73552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73557       };
73558     }
73559   }
73560
73561 }
73562
73563
73564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73565   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73566
73567   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73568   {
73569     try {
73570       (arg1)->HideIndicator();
73571     } catch (std::out_of_range& e) {
73572       {
73573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73574       };
73575     } catch (std::exception& e) {
73576       {
73577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73578       };
73579     } catch (Dali::DaliException e) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73586       };
73587     }
73588   }
73589
73590 }
73591
73592
73593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73594   void * jresult ;
73595   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73596   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73597
73598   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73599   {
73600     try {
73601       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73602     } catch (std::out_of_range& e) {
73603       {
73604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (std::exception& e) {
73607       {
73608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73609       };
73610     } catch (Dali::DaliException e) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73613       };
73614     } catch (...) {
73615       {
73616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73617       };
73618     }
73619   }
73620
73621   jresult = (void *)result;
73622   return jresult;
73623 }
73624
73625
73626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73627   void * jresult ;
73628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73629   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73630
73631   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73632   {
73633     try {
73634       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73635     } catch (std::out_of_range& e) {
73636       {
73637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73638       };
73639     } catch (std::exception& e) {
73640       {
73641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73642       };
73643     } catch (Dali::DaliException e) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73650       };
73651     }
73652   }
73653
73654   jresult = (void *)result;
73655   return jresult;
73656 }
73657
73658
73659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73660   int jresult ;
73661   int result;
73662
73663   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73664   jresult = (int)result;
73665   return jresult;
73666 }
73667
73668
73669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73670   int jresult ;
73671   int result;
73672
73673   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73674   jresult = (int)result;
73675   return jresult;
73676 }
73677
73678
73679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73680   int jresult ;
73681   int result;
73682
73683   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73684   jresult = (int)result;
73685   return jresult;
73686 }
73687
73688
73689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73690   int jresult ;
73691   int result;
73692
73693   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73694   jresult = (int)result;
73695   return jresult;
73696 }
73697
73698
73699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73700   int jresult ;
73701   int result;
73702
73703   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73704   jresult = (int)result;
73705   return jresult;
73706 }
73707
73708
73709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73710   int jresult ;
73711   int result;
73712
73713   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73714   jresult = (int)result;
73715   return jresult;
73716 }
73717
73718
73719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73720   int jresult ;
73721   int result;
73722
73723   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73724   jresult = (int)result;
73725   return jresult;
73726 }
73727
73728
73729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73730   int jresult ;
73731   int result;
73732
73733   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73734   jresult = (int)result;
73735   return jresult;
73736 }
73737
73738
73739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73740   int jresult ;
73741   int result;
73742
73743   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73744   jresult = (int)result;
73745   return jresult;
73746 }
73747
73748
73749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73750   int jresult ;
73751   int result;
73752
73753   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73754   jresult = (int)result;
73755   return jresult;
73756 }
73757
73758
73759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73760   int jresult ;
73761   int result;
73762
73763   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73764   jresult = (int)result;
73765   return jresult;
73766 }
73767
73768
73769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73770   int jresult ;
73771   int result;
73772
73773   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73774   jresult = (int)result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73780   int jresult ;
73781   int result;
73782
73783   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73784   jresult = (int)result;
73785   return jresult;
73786 }
73787
73788
73789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73790   int jresult ;
73791   int result;
73792
73793   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73794   jresult = (int)result;
73795   return jresult;
73796 }
73797
73798
73799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73800   void * jresult ;
73801   Dali::Toolkit::Scrollable::Property *result = 0 ;
73802
73803   {
73804     try {
73805       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73806     } catch (std::out_of_range& e) {
73807       {
73808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (std::exception& e) {
73811       {
73812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73813       };
73814     } catch (Dali::DaliException e) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73817       };
73818     } catch (...) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73821       };
73822     }
73823   }
73824
73825   jresult = (void *)result;
73826   return jresult;
73827 }
73828
73829
73830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73831   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73832
73833   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73834   {
73835     try {
73836       delete arg1;
73837     } catch (std::out_of_range& e) {
73838       {
73839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73840       };
73841     } catch (std::exception& e) {
73842       {
73843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73844       };
73845     } catch (Dali::DaliException e) {
73846       {
73847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73848       };
73849     } catch (...) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73852       };
73853     }
73854   }
73855
73856 }
73857
73858
73859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73860   void * jresult ;
73861   Dali::Toolkit::Scrollable *result = 0 ;
73862
73863   {
73864     try {
73865       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73866     } catch (std::out_of_range& e) {
73867       {
73868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73869       };
73870     } catch (std::exception& e) {
73871       {
73872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73873       };
73874     } catch (Dali::DaliException e) {
73875       {
73876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73877       };
73878     } catch (...) {
73879       {
73880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73881       };
73882     }
73883   }
73884
73885   jresult = (void *)result;
73886   return jresult;
73887 }
73888
73889
73890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73891   void * jresult ;
73892   Dali::Toolkit::Scrollable *arg1 = 0 ;
73893   Dali::Toolkit::Scrollable *result = 0 ;
73894
73895   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73896   if (!arg1) {
73897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73898     return 0;
73899   }
73900   {
73901     try {
73902       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73903     } catch (std::out_of_range& e) {
73904       {
73905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73906       };
73907     } catch (std::exception& e) {
73908       {
73909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73910       };
73911     } catch (Dali::DaliException e) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73914       };
73915     } catch (...) {
73916       {
73917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73918       };
73919     }
73920   }
73921
73922   jresult = (void *)result;
73923   return jresult;
73924 }
73925
73926
73927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73928   void * jresult ;
73929   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73930   Dali::Toolkit::Scrollable *arg2 = 0 ;
73931   Dali::Toolkit::Scrollable *result = 0 ;
73932
73933   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73934   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73935   if (!arg2) {
73936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73937     return 0;
73938   }
73939   {
73940     try {
73941       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73942     } catch (std::out_of_range& e) {
73943       {
73944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73945       };
73946     } catch (std::exception& e) {
73947       {
73948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73949       };
73950     } catch (Dali::DaliException e) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73953       };
73954     } catch (...) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73957       };
73958     }
73959   }
73960
73961   jresult = (void *)result;
73962   return jresult;
73963 }
73964
73965
73966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73967   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73968
73969   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73970   {
73971     try {
73972       delete arg1;
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73980       };
73981     } catch (Dali::DaliException e) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73984       };
73985     } catch (...) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73988       };
73989     }
73990   }
73991
73992 }
73993
73994
73995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73996   void * jresult ;
73997   Dali::BaseHandle arg1 ;
73998   Dali::BaseHandle *argp1 ;
73999   Dali::Toolkit::Scrollable result;
74000
74001   argp1 = (Dali::BaseHandle *)jarg1;
74002   if (!argp1) {
74003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74004     return 0;
74005   }
74006   arg1 = *argp1;
74007   {
74008     try {
74009       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74010     } catch (std::out_of_range& e) {
74011       {
74012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (std::exception& e) {
74015       {
74016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (Dali::DaliException e) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74021       };
74022     } catch (...) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74025       };
74026     }
74027   }
74028
74029   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74030   return jresult;
74031 }
74032
74033
74034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74035   unsigned int jresult ;
74036   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74037   bool result;
74038
74039   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74040   {
74041     try {
74042       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74043     } catch (std::out_of_range& e) {
74044       {
74045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74046       };
74047     } catch (std::exception& e) {
74048       {
74049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74050       };
74051     } catch (Dali::DaliException e) {
74052       {
74053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74054       };
74055     } catch (...) {
74056       {
74057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74058       };
74059     }
74060   }
74061
74062   jresult = result;
74063   return jresult;
74064 }
74065
74066
74067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74068   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74069   bool arg2 ;
74070
74071   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74072   arg2 = jarg2 ? true : false;
74073   {
74074     try {
74075       (arg1)->SetOvershootEnabled(arg2);
74076     } catch (std::out_of_range& e) {
74077       {
74078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74079       };
74080     } catch (std::exception& e) {
74081       {
74082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (Dali::DaliException e) {
74085       {
74086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74087       };
74088     } catch (...) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74091       };
74092     }
74093   }
74094
74095 }
74096
74097
74098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74099   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74100   Dali::Vector4 *arg2 = 0 ;
74101
74102   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74103   arg2 = (Dali::Vector4 *)jarg2;
74104   if (!arg2) {
74105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74106     return ;
74107   }
74108   {
74109     try {
74110       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74118       };
74119     } catch (Dali::DaliException e) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74122       };
74123     } catch (...) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74126       };
74127     }
74128   }
74129
74130 }
74131
74132
74133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74134   void * jresult ;
74135   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74136   Dali::Vector4 result;
74137
74138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74139   {
74140     try {
74141       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74142     } catch (std::out_of_range& e) {
74143       {
74144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74145       };
74146     } catch (std::exception& e) {
74147       {
74148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74149       };
74150     } catch (Dali::DaliException e) {
74151       {
74152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74153       };
74154     } catch (...) {
74155       {
74156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74157       };
74158     }
74159   }
74160
74161   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74168   float arg2 ;
74169
74170   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74171   arg2 = (float)jarg2;
74172   {
74173     try {
74174       (arg1)->SetOvershootAnimationSpeed(arg2);
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (Dali::DaliException e) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74186       };
74187     } catch (...) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74190       };
74191     }
74192   }
74193
74194 }
74195
74196
74197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74198   float jresult ;
74199   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74200   float result;
74201
74202   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74203   {
74204     try {
74205       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74206     } catch (std::out_of_range& e) {
74207       {
74208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74209       };
74210     } catch (std::exception& e) {
74211       {
74212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (Dali::DaliException e) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74217       };
74218     } catch (...) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74221       };
74222     }
74223   }
74224
74225   jresult = result;
74226   return jresult;
74227 }
74228
74229
74230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74231   void * jresult ;
74232   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74233   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74234
74235   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74236   {
74237     try {
74238       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74239     } catch (std::out_of_range& e) {
74240       {
74241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74242       };
74243     } catch (std::exception& e) {
74244       {
74245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (Dali::DaliException e) {
74248       {
74249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74250       };
74251     } catch (...) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74254       };
74255     }
74256   }
74257
74258   jresult = (void *)result;
74259   return jresult;
74260 }
74261
74262
74263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74264   void * jresult ;
74265   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74266   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74267
74268   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74269   {
74270     try {
74271       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74272     } catch (std::out_of_range& e) {
74273       {
74274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (std::exception& e) {
74277       {
74278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (Dali::DaliException e) {
74281       {
74282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74283       };
74284     } catch (...) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74287       };
74288     }
74289   }
74290
74291   jresult = (void *)result;
74292   return jresult;
74293 }
74294
74295
74296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74297   void * jresult ;
74298   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74299   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74300
74301   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74302   {
74303     try {
74304       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74305     } catch (std::out_of_range& e) {
74306       {
74307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74308       };
74309     } catch (std::exception& e) {
74310       {
74311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (Dali::DaliException e) {
74314       {
74315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74316       };
74317     } catch (...) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74320       };
74321     }
74322   }
74323
74324   jresult = (void *)result;
74325   return jresult;
74326 }
74327
74328
74329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74330   unsigned int jresult ;
74331   Dali::Toolkit::ControlOrientation::Type arg1 ;
74332   bool result;
74333
74334   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74335   {
74336     try {
74337       result = (bool)Dali::Toolkit::IsVertical(arg1);
74338     } catch (std::out_of_range& e) {
74339       {
74340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74341       };
74342     } catch (std::exception& e) {
74343       {
74344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74345       };
74346     } catch (Dali::DaliException e) {
74347       {
74348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74349       };
74350     } catch (...) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74353       };
74354     }
74355   }
74356
74357   jresult = result;
74358   return jresult;
74359 }
74360
74361
74362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74363   unsigned int jresult ;
74364   Dali::Toolkit::ControlOrientation::Type arg1 ;
74365   bool result;
74366
74367   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74368   {
74369     try {
74370       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74371     } catch (std::out_of_range& e) {
74372       {
74373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74374       };
74375     } catch (std::exception& e) {
74376       {
74377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (Dali::DaliException e) {
74380       {
74381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74382       };
74383     } catch (...) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74386       };
74387     }
74388   }
74389
74390   jresult = result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74396   void * jresult ;
74397   unsigned int arg1 ;
74398   unsigned int arg2 ;
74399   Dali::Toolkit::ItemRange *result = 0 ;
74400
74401   arg1 = (unsigned int)jarg1;
74402   arg2 = (unsigned int)jarg2;
74403   {
74404     try {
74405       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74406     } catch (std::out_of_range& e) {
74407       {
74408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74409       };
74410     } catch (std::exception& e) {
74411       {
74412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74413       };
74414     } catch (Dali::DaliException e) {
74415       {
74416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74417       };
74418     } catch (...) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74421       };
74422     }
74423   }
74424
74425   jresult = (void *)result;
74426   return jresult;
74427 }
74428
74429
74430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74431   void * jresult ;
74432   Dali::Toolkit::ItemRange *arg1 = 0 ;
74433   Dali::Toolkit::ItemRange *result = 0 ;
74434
74435   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74436   if (!arg1) {
74437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74438     return 0;
74439   }
74440   {
74441     try {
74442       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (Dali::DaliException e) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74454       };
74455     } catch (...) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74458       };
74459     }
74460   }
74461
74462   jresult = (void *)result;
74463   return jresult;
74464 }
74465
74466
74467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74468   void * jresult ;
74469   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74470   Dali::Toolkit::ItemRange *arg2 = 0 ;
74471   Dali::Toolkit::ItemRange *result = 0 ;
74472
74473   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74474   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74475   if (!arg2) {
74476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74477     return 0;
74478   }
74479   {
74480     try {
74481       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (Dali::DaliException e) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74493       };
74494     } catch (...) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74497       };
74498     }
74499   }
74500
74501   jresult = (void *)result;
74502   return jresult;
74503 }
74504
74505
74506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74507   unsigned int jresult ;
74508   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74509   unsigned int arg2 ;
74510   bool result;
74511
74512   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74513   arg2 = (unsigned int)jarg2;
74514   {
74515     try {
74516       result = (bool)(arg1)->Within(arg2);
74517     } catch (std::out_of_range& e) {
74518       {
74519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74520       };
74521     } catch (std::exception& e) {
74522       {
74523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74524       };
74525     } catch (Dali::DaliException e) {
74526       {
74527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74528       };
74529     } catch (...) {
74530       {
74531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74532       };
74533     }
74534   }
74535
74536   jresult = result;
74537   return jresult;
74538 }
74539
74540
74541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74542   void * jresult ;
74543   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74544   Dali::Toolkit::ItemRange *arg2 = 0 ;
74545   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74546
74547   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74548   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74549   if (!arg2) {
74550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74551     return 0;
74552   }
74553   {
74554     try {
74555       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (Dali::DaliException e) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74571       };
74572     }
74573   }
74574
74575   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74576   return jresult;
74577 }
74578
74579
74580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74581   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74582   unsigned int arg2 ;
74583
74584   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74585   arg2 = (unsigned int)jarg2;
74586   if (arg1) (arg1)->begin = arg2;
74587 }
74588
74589
74590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74591   unsigned int jresult ;
74592   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74593   unsigned int result;
74594
74595   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74596   result = (unsigned int) ((arg1)->begin);
74597   jresult = result;
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74603   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74604   unsigned int arg2 ;
74605
74606   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74607   arg2 = (unsigned int)jarg2;
74608   if (arg1) (arg1)->end = arg2;
74609 }
74610
74611
74612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74613   unsigned int jresult ;
74614   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74615   unsigned int result;
74616
74617   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74618   result = (unsigned int) ((arg1)->end);
74619   jresult = result;
74620   return jresult;
74621 }
74622
74623
74624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74625   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74626
74627   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74628   {
74629     try {
74630       delete arg1;
74631     } catch (std::out_of_range& e) {
74632       {
74633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74634       };
74635     } catch (std::exception& e) {
74636       {
74637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (Dali::DaliException e) {
74640       {
74641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74642       };
74643     } catch (...) {
74644       {
74645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74646       };
74647     }
74648   }
74649
74650 }
74651
74652
74653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74655
74656   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74657   {
74658     try {
74659       delete arg1;
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74667       };
74668     } catch (Dali::DaliException e) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74675       };
74676     }
74677   }
74678
74679 }
74680
74681
74682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74683   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74684   Dali::Toolkit::ControlOrientation::Type arg2 ;
74685
74686   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74687   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74688   {
74689     try {
74690       (arg1)->SetOrientation(arg2);
74691     } catch (std::out_of_range& e) {
74692       {
74693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74694       };
74695     } catch (std::exception& e) {
74696       {
74697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74698       };
74699     } catch (Dali::DaliException e) {
74700       {
74701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74706       };
74707     }
74708   }
74709
74710 }
74711
74712
74713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74714   int jresult ;
74715   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74716   Dali::Toolkit::ControlOrientation::Type result;
74717
74718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74719   {
74720     try {
74721       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74722     } catch (std::out_of_range& e) {
74723       {
74724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (std::exception& e) {
74727       {
74728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74729       };
74730     } catch (Dali::DaliException e) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74733       };
74734     } catch (...) {
74735       {
74736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74737       };
74738     }
74739   }
74740
74741   jresult = (int)result;
74742   return jresult;
74743 }
74744
74745
74746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74747   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74748   Dali::Property::Map *arg2 = 0 ;
74749
74750   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74751   arg2 = (Dali::Property::Map *)jarg2;
74752   if (!arg2) {
74753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74754     return ;
74755   }
74756   {
74757     try {
74758       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74759     } catch (std::out_of_range& e) {
74760       {
74761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74762       };
74763     } catch (std::exception& e) {
74764       {
74765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74766       };
74767     } catch (Dali::DaliException e) {
74768       {
74769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74770       };
74771     } catch (...) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74774       };
74775     }
74776   }
74777
74778 }
74779
74780
74781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74782   void * jresult ;
74783   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74784   Dali::Property::Map result;
74785
74786   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74787   {
74788     try {
74789       result = (arg1)->GetLayoutProperties();
74790     } catch (std::out_of_range& e) {
74791       {
74792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74793       };
74794     } catch (std::exception& e) {
74795       {
74796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74797       };
74798     } catch (Dali::DaliException e) {
74799       {
74800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74801       };
74802     } catch (...) {
74803       {
74804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74805       };
74806     }
74807   }
74808
74809   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74810   return jresult;
74811 }
74812
74813
74814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74815   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74816   unsigned int arg2 ;
74817   Dali::Vector3 *arg3 = 0 ;
74818   Dali::Vector3 *arg4 = 0 ;
74819
74820   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74821   arg2 = (unsigned int)jarg2;
74822   arg3 = (Dali::Vector3 *)jarg3;
74823   if (!arg3) {
74824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74825     return ;
74826   }
74827   arg4 = (Dali::Vector3 *)jarg4;
74828   if (!arg4) {
74829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74830     return ;
74831   }
74832   {
74833     try {
74834       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74835     } catch (std::out_of_range& e) {
74836       {
74837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (std::exception& e) {
74840       {
74841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (Dali::DaliException e) {
74844       {
74845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74846       };
74847     } catch (...) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74850       };
74851     }
74852   }
74853
74854 }
74855
74856
74857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74858   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74859   Dali::Vector3 *arg2 = 0 ;
74860
74861   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74862   arg2 = (Dali::Vector3 *)jarg2;
74863   if (!arg2) {
74864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74865     return ;
74866   }
74867   {
74868     try {
74869       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74870     } catch (std::out_of_range& e) {
74871       {
74872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74873       };
74874     } catch (std::exception& e) {
74875       {
74876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74877       };
74878     } catch (Dali::DaliException e) {
74879       {
74880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74881       };
74882     } catch (...) {
74883       {
74884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74885       };
74886     }
74887   }
74888
74889 }
74890
74891
74892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74893   float jresult ;
74894   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74895   unsigned int arg2 ;
74896   Dali::Vector3 arg3 ;
74897   Dali::Vector3 *argp3 ;
74898   float result;
74899
74900   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74901   arg2 = (unsigned int)jarg2;
74902   argp3 = (Dali::Vector3 *)jarg3;
74903   if (!argp3) {
74904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74905     return 0;
74906   }
74907   arg3 = *argp3;
74908   {
74909     try {
74910       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74911     } catch (std::out_of_range& e) {
74912       {
74913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74914       };
74915     } catch (std::exception& e) {
74916       {
74917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (Dali::DaliException e) {
74920       {
74921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74922       };
74923     } catch (...) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74926       };
74927     }
74928   }
74929
74930   jresult = result;
74931   return jresult;
74932 }
74933
74934
74935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74936   float jresult ;
74937   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74938   float arg2 ;
74939   float result;
74940
74941   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74942   arg2 = (float)jarg2;
74943   {
74944     try {
74945       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74946     } catch (std::out_of_range& e) {
74947       {
74948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74949       };
74950     } catch (std::exception& e) {
74951       {
74952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (Dali::DaliException e) {
74955       {
74956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74957       };
74958     } catch (...) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74961       };
74962     }
74963   }
74964
74965   jresult = result;
74966   return jresult;
74967 }
74968
74969
74970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74971   float jresult ;
74972   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74973   unsigned int arg2 ;
74974   float result;
74975
74976   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74977   arg2 = (unsigned int)jarg2;
74978   {
74979     try {
74980       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74981     } catch (std::out_of_range& e) {
74982       {
74983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (std::exception& e) {
74986       {
74987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (Dali::DaliException e) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74992       };
74993     } catch (...) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74996       };
74997     }
74998   }
74999
75000   jresult = result;
75001   return jresult;
75002 }
75003
75004
75005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75006   void * jresult ;
75007   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75008   float arg2 ;
75009   Dali::Vector3 arg3 ;
75010   Dali::Vector3 *argp3 ;
75011   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75012
75013   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75014   arg2 = (float)jarg2;
75015   argp3 = (Dali::Vector3 *)jarg3;
75016   if (!argp3) {
75017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75018     return 0;
75019   }
75020   arg3 = *argp3;
75021   {
75022     try {
75023       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75024     } catch (std::out_of_range& e) {
75025       {
75026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75027       };
75028     } catch (std::exception& e) {
75029       {
75030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75031       };
75032     } catch (Dali::DaliException e) {
75033       {
75034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75035       };
75036     } catch (...) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75039       };
75040     }
75041   }
75042
75043   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75044   return jresult;
75045 }
75046
75047
75048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75049   float jresult ;
75050   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75051   int arg2 ;
75052   float arg3 ;
75053   Dali::Vector3 *arg4 = 0 ;
75054   float result;
75055
75056   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75057   arg2 = (int)jarg2;
75058   arg3 = (float)jarg3;
75059   arg4 = (Dali::Vector3 *)jarg4;
75060   if (!arg4) {
75061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75062     return 0;
75063   }
75064   {
75065     try {
75066       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75067     } catch (std::out_of_range& e) {
75068       {
75069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (std::exception& e) {
75072       {
75073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75074       };
75075     } catch (Dali::DaliException e) {
75076       {
75077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75078       };
75079     } catch (...) {
75080       {
75081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75082       };
75083     }
75084   }
75085
75086   jresult = result;
75087   return jresult;
75088 }
75089
75090
75091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75092   unsigned int jresult ;
75093   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75094   Dali::Vector3 arg2 ;
75095   Dali::Vector3 *argp2 ;
75096   unsigned int result;
75097
75098   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75099   argp2 = (Dali::Vector3 *)jarg2;
75100   if (!argp2) {
75101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75102     return 0;
75103   }
75104   arg2 = *argp2;
75105   {
75106     try {
75107       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75108     } catch (std::out_of_range& e) {
75109       {
75110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (std::exception& e) {
75113       {
75114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (Dali::DaliException e) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75119       };
75120     } catch (...) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75123       };
75124     }
75125   }
75126
75127   jresult = result;
75128   return jresult;
75129 }
75130
75131
75132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75133   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75134   unsigned int arg2 ;
75135   Dali::Vector3 *arg3 = 0 ;
75136   Dali::Vector3 *arg4 = 0 ;
75137
75138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75139   arg2 = (unsigned int)jarg2;
75140   arg3 = (Dali::Vector3 *)jarg3;
75141   if (!arg3) {
75142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75143     return ;
75144   }
75145   arg4 = (Dali::Vector3 *)jarg4;
75146   if (!arg4) {
75147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75148     return ;
75149   }
75150   {
75151     try {
75152       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75153     } catch (std::out_of_range& e) {
75154       {
75155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75156       };
75157     } catch (std::exception& e) {
75158       {
75159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75160       };
75161     } catch (Dali::DaliException e) {
75162       {
75163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75164       };
75165     } catch (...) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75168       };
75169     }
75170   }
75171
75172 }
75173
75174
75175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75176   void * jresult ;
75177   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75178   Dali::Degree result;
75179
75180   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75181   {
75182     try {
75183       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75184     } catch (std::out_of_range& e) {
75185       {
75186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75187       };
75188     } catch (std::exception& e) {
75189       {
75190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75191       };
75192     } catch (Dali::DaliException e) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75199       };
75200     }
75201   }
75202
75203   jresult = new Dali::Degree((const Dali::Degree &)result);
75204   return jresult;
75205 }
75206
75207
75208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75209   float jresult ;
75210   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75211   float result;
75212
75213   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75214   {
75215     try {
75216       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75217     } catch (std::out_of_range& e) {
75218       {
75219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75220       };
75221     } catch (std::exception& e) {
75222       {
75223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (Dali::DaliException e) {
75226       {
75227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235
75236   jresult = result;
75237   return jresult;
75238 }
75239
75240
75241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75242   float jresult ;
75243   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75244   float result;
75245
75246   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75247   {
75248     try {
75249       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75250     } catch (std::out_of_range& e) {
75251       {
75252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75253       };
75254     } catch (std::exception& e) {
75255       {
75256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75257       };
75258     } catch (Dali::DaliException e) {
75259       {
75260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75261       };
75262     } catch (...) {
75263       {
75264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75265       };
75266     }
75267   }
75268
75269   jresult = result;
75270   return jresult;
75271 }
75272
75273
75274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75275   float jresult ;
75276   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75277   float result;
75278
75279   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75280   {
75281     try {
75282       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75283     } catch (std::out_of_range& e) {
75284       {
75285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75286       };
75287     } catch (std::exception& e) {
75288       {
75289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (Dali::DaliException e) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75294       };
75295     } catch (...) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75298       };
75299     }
75300   }
75301
75302   jresult = result;
75303   return jresult;
75304 }
75305
75306
75307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75308   int jresult ;
75309   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75310   int arg2 ;
75311   int arg3 ;
75312   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75313   bool arg5 ;
75314   int result;
75315
75316   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75317   arg2 = (int)jarg2;
75318   arg3 = (int)jarg3;
75319   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75320   arg5 = jarg5 ? true : false;
75321   {
75322     try {
75323       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75324     } catch (std::out_of_range& e) {
75325       {
75326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75327       };
75328     } catch (std::exception& e) {
75329       {
75330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (Dali::DaliException e) {
75333       {
75334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75335       };
75336     } catch (...) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75339       };
75340     }
75341   }
75342
75343   jresult = result;
75344   return jresult;
75345 }
75346
75347
75348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75349   float jresult ;
75350   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75351   float result;
75352
75353   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75354   {
75355     try {
75356       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75357     } catch (std::out_of_range& e) {
75358       {
75359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75360       };
75361     } catch (std::exception& e) {
75362       {
75363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75364       };
75365     } catch (Dali::DaliException e) {
75366       {
75367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75368       };
75369     } catch (...) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75372       };
75373     }
75374   }
75375
75376   jresult = result;
75377   return jresult;
75378 }
75379
75380
75381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75382   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75383   Dali::Actor *arg2 = 0 ;
75384   int arg3 ;
75385   Dali::Vector3 *arg4 = 0 ;
75386   Dali::Actor *arg5 = 0 ;
75387
75388   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75389   arg2 = (Dali::Actor *)jarg2;
75390   if (!arg2) {
75391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75392     return ;
75393   }
75394   arg3 = (int)jarg3;
75395   arg4 = (Dali::Vector3 *)jarg4;
75396   if (!arg4) {
75397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75398     return ;
75399   }
75400   arg5 = (Dali::Actor *)jarg5;
75401   if (!arg5) {
75402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75403     return ;
75404   }
75405   {
75406     try {
75407       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75408     } catch (std::out_of_range& e) {
75409       {
75410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75411       };
75412     } catch (std::exception& e) {
75413       {
75414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75415       };
75416     } catch (Dali::DaliException e) {
75417       {
75418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75419       };
75420     } catch (...) {
75421       {
75422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75423       };
75424     }
75425   }
75426
75427 }
75428
75429
75430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75431   void * jresult ;
75432   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75433   int arg2 ;
75434   float arg3 ;
75435   Dali::Vector3 *arg4 = 0 ;
75436   Dali::Vector3 result;
75437
75438   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75439   arg2 = (int)jarg2;
75440   arg3 = (float)jarg3;
75441   arg4 = (Dali::Vector3 *)jarg4;
75442   if (!arg4) {
75443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75444     return 0;
75445   }
75446   {
75447     try {
75448       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75474   void * jresult ;
75475   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75476   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75477
75478   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75479   {
75480     try {
75481       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75482     } catch (std::out_of_range& e) {
75483       {
75484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75485       };
75486     } catch (std::exception& e) {
75487       {
75488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75489       };
75490     } catch (Dali::DaliException e) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75493       };
75494     } catch (...) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75497       };
75498     }
75499   }
75500
75501   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75502   return jresult;
75503 }
75504
75505
75506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75507   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75508
75509   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75510   {
75511     try {
75512       delete arg1;
75513     } catch (std::out_of_range& e) {
75514       {
75515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75516       };
75517     } catch (std::exception& e) {
75518       {
75519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75520       };
75521     } catch (Dali::DaliException e) {
75522       {
75523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75524       };
75525     } catch (...) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75528       };
75529     }
75530   }
75531
75532 }
75533
75534
75535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75536   unsigned int jresult ;
75537   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75538   unsigned int result;
75539
75540   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75541   {
75542     try {
75543       result = (unsigned int)(arg1)->GetNumberOfItems();
75544     } catch (std::out_of_range& e) {
75545       {
75546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75547       };
75548     } catch (std::exception& e) {
75549       {
75550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75551       };
75552     } catch (Dali::DaliException e) {
75553       {
75554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75555       };
75556     } catch (...) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75559       };
75560     }
75561   }
75562
75563   jresult = result;
75564   return jresult;
75565 }
75566
75567
75568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75569   void * jresult ;
75570   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75571   unsigned int arg2 ;
75572   Dali::Actor result;
75573
75574   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75575   arg2 = (unsigned int)jarg2;
75576   {
75577     try {
75578       result = (arg1)->NewItem(arg2);
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (Dali::DaliException e) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75590       };
75591     } catch (...) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75594       };
75595     }
75596   }
75597
75598   jresult = new Dali::Actor((const Dali::Actor &)result);
75599   return jresult;
75600 }
75601
75602
75603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75604   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75605   unsigned int arg2 ;
75606   Dali::Actor arg3 ;
75607   Dali::Actor *argp3 ;
75608
75609   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75610   arg2 = (unsigned int)jarg2;
75611   argp3 = (Dali::Actor *)jarg3;
75612   if (!argp3) {
75613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75614     return ;
75615   }
75616   arg3 = *argp3;
75617   {
75618     try {
75619       (arg1)->ItemReleased(arg2,arg3);
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (Dali::DaliException e) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75635       };
75636     }
75637   }
75638
75639 }
75640
75641
75642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75643   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75644   unsigned int arg2 ;
75645   Dali::Actor arg3 ;
75646   Dali::Actor *argp3 ;
75647
75648   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75649   arg2 = (unsigned int)jarg2;
75650   argp3 = (Dali::Actor *)jarg3;
75651   if (!argp3) {
75652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75653     return ;
75654   }
75655   arg3 = *argp3;
75656   {
75657     try {
75658       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75659     } catch (std::out_of_range& e) {
75660       {
75661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75662       };
75663     } catch (std::exception& e) {
75664       {
75665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75666       };
75667     } catch (Dali::DaliException e) {
75668       {
75669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75674       };
75675     }
75676   }
75677
75678 }
75679
75680
75681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75682   void * jresult ;
75683   Dali::Toolkit::ItemFactory *result = 0 ;
75684
75685   {
75686     try {
75687       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75688     } catch (std::out_of_range& e) {
75689       {
75690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75691       };
75692     } catch (std::exception& e) {
75693       {
75694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75695       };
75696     } catch (Dali::DaliException e) {
75697       {
75698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75699       };
75700     } catch (...) {
75701       {
75702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75703       };
75704     }
75705   }
75706
75707   jresult = (void *)result;
75708   return jresult;
75709 }
75710
75711
75712 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) {
75713   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75714   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75715   if (director) {
75716     director->swig_connect_director(callback0, callback1, callback2);
75717   }
75718 }
75719
75720
75721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75722   int jresult ;
75723   int result;
75724
75725   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75726   jresult = (int)result;
75727   return jresult;
75728 }
75729
75730
75731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75732   int jresult ;
75733   int result;
75734
75735   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75736   jresult = (int)result;
75737   return jresult;
75738 }
75739
75740
75741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75742   int jresult ;
75743   int result;
75744
75745   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75746   jresult = (int)result;
75747   return jresult;
75748 }
75749
75750
75751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75752   int jresult ;
75753   int result;
75754
75755   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75756   jresult = (int)result;
75757   return jresult;
75758 }
75759
75760
75761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75762   int jresult ;
75763   int result;
75764
75765   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75766   jresult = (int)result;
75767   return jresult;
75768 }
75769
75770
75771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75772   int jresult ;
75773   int result;
75774
75775   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75776   jresult = (int)result;
75777   return jresult;
75778 }
75779
75780
75781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75782   int jresult ;
75783   int result;
75784
75785   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75786   jresult = (int)result;
75787   return jresult;
75788 }
75789
75790
75791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75792   int jresult ;
75793   int result;
75794
75795   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75796   jresult = (int)result;
75797   return jresult;
75798 }
75799
75800
75801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75802   int jresult ;
75803   int result;
75804
75805   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75806   jresult = (int)result;
75807   return jresult;
75808 }
75809
75810
75811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75812   int jresult ;
75813   int result;
75814
75815   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75816   jresult = (int)result;
75817   return jresult;
75818 }
75819
75820
75821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75822   int jresult ;
75823   int result;
75824
75825   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75826   jresult = (int)result;
75827   return jresult;
75828 }
75829
75830
75831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75832   void * jresult ;
75833   Dali::Toolkit::ItemView::Property *result = 0 ;
75834
75835   {
75836     try {
75837       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75838     } catch (std::out_of_range& e) {
75839       {
75840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75841       };
75842     } catch (std::exception& e) {
75843       {
75844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (Dali::DaliException e) {
75847       {
75848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75849       };
75850     } catch (...) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75853       };
75854     }
75855   }
75856
75857   jresult = (void *)result;
75858   return jresult;
75859 }
75860
75861
75862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75863   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75864
75865   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75866   {
75867     try {
75868       delete arg1;
75869     } catch (std::out_of_range& e) {
75870       {
75871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (std::exception& e) {
75874       {
75875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (Dali::DaliException e) {
75878       {
75879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75880       };
75881     } catch (...) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75884       };
75885     }
75886   }
75887
75888 }
75889
75890
75891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75892   void * jresult ;
75893   Dali::Toolkit::ItemView *result = 0 ;
75894
75895   {
75896     try {
75897       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75898     } catch (std::out_of_range& e) {
75899       {
75900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75901       };
75902     } catch (std::exception& e) {
75903       {
75904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75905       };
75906     } catch (Dali::DaliException e) {
75907       {
75908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75909       };
75910     } catch (...) {
75911       {
75912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75913       };
75914     }
75915   }
75916
75917   jresult = (void *)result;
75918   return jresult;
75919 }
75920
75921
75922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75923   void * jresult ;
75924   Dali::Toolkit::ItemView *arg1 = 0 ;
75925   Dali::Toolkit::ItemView *result = 0 ;
75926
75927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75928   if (!arg1) {
75929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75930     return 0;
75931   }
75932   {
75933     try {
75934       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75942       };
75943     } catch (Dali::DaliException e) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75946       };
75947     } catch (...) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75950       };
75951     }
75952   }
75953
75954   jresult = (void *)result;
75955   return jresult;
75956 }
75957
75958
75959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75960   void * jresult ;
75961   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75962   Dali::Toolkit::ItemView *arg2 = 0 ;
75963   Dali::Toolkit::ItemView *result = 0 ;
75964
75965   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75966   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75967   if (!arg2) {
75968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75969     return 0;
75970   }
75971   {
75972     try {
75973       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75974     } catch (std::out_of_range& e) {
75975       {
75976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75977       };
75978     } catch (std::exception& e) {
75979       {
75980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75981       };
75982     } catch (Dali::DaliException e) {
75983       {
75984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75985       };
75986     } catch (...) {
75987       {
75988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75989       };
75990     }
75991   }
75992
75993   jresult = (void *)result;
75994   return jresult;
75995 }
75996
75997
75998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76000
76001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76002   {
76003     try {
76004       delete arg1;
76005     } catch (std::out_of_range& e) {
76006       {
76007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76008       };
76009     } catch (std::exception& e) {
76010       {
76011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (Dali::DaliException e) {
76014       {
76015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76020       };
76021     }
76022   }
76023
76024 }
76025
76026
76027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76028   void * jresult ;
76029   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76030   Dali::Toolkit::ItemView result;
76031
76032   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76033   if (!arg1) {
76034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76035     return 0;
76036   }
76037   {
76038     try {
76039       result = Dali::Toolkit::ItemView::New(*arg1);
76040     } catch (std::out_of_range& e) {
76041       {
76042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76043       };
76044     } catch (std::exception& e) {
76045       {
76046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (Dali::DaliException e) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76051       };
76052     } catch (...) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76055       };
76056     }
76057   }
76058
76059   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76060   return jresult;
76061 }
76062
76063
76064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76065   void * jresult ;
76066   Dali::BaseHandle arg1 ;
76067   Dali::BaseHandle *argp1 ;
76068   Dali::Toolkit::ItemView result;
76069
76070   argp1 = (Dali::BaseHandle *)jarg1;
76071   if (!argp1) {
76072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76073     return 0;
76074   }
76075   arg1 = *argp1;
76076   {
76077     try {
76078       result = Dali::Toolkit::ItemView::DownCast(arg1);
76079     } catch (std::out_of_range& e) {
76080       {
76081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76082       };
76083     } catch (std::exception& e) {
76084       {
76085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (Dali::DaliException e) {
76088       {
76089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76090       };
76091     } catch (...) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76094       };
76095     }
76096   }
76097
76098   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76099   return jresult;
76100 }
76101
76102
76103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76104   unsigned int jresult ;
76105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76106   unsigned int result;
76107
76108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76109   {
76110     try {
76111       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76112     } catch (std::out_of_range& e) {
76113       {
76114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76115       };
76116     } catch (std::exception& e) {
76117       {
76118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76119       };
76120     } catch (Dali::DaliException e) {
76121       {
76122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76123       };
76124     } catch (...) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76127       };
76128     }
76129   }
76130
76131   jresult = result;
76132   return jresult;
76133 }
76134
76135
76136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76138   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76139
76140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76141   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76142   if (!arg2) {
76143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76144     return ;
76145   }
76146   {
76147     try {
76148       (arg1)->AddLayout(*arg2);
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76156       };
76157     } catch (Dali::DaliException e) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76160       };
76161     } catch (...) {
76162       {
76163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76164       };
76165     }
76166   }
76167
76168 }
76169
76170
76171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76172   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76173   unsigned int arg2 ;
76174
76175   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76176   arg2 = (unsigned int)jarg2;
76177   {
76178     try {
76179       (arg1)->RemoveLayout(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 void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76203   void * jresult ;
76204   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76205   unsigned int arg2 ;
76206   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76207
76208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76209   arg2 = (unsigned int)jarg2;
76210   {
76211     try {
76212       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76213     } catch (std::out_of_range& e) {
76214       {
76215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76216       };
76217     } catch (std::exception& e) {
76218       {
76219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (Dali::DaliException e) {
76222       {
76223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76228       };
76229     }
76230   }
76231
76232   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76233   return jresult;
76234 }
76235
76236
76237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76238   void * jresult ;
76239   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76240   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76241
76242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76243   {
76244     try {
76245       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76246     } catch (std::out_of_range& e) {
76247       {
76248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76249       };
76250     } catch (std::exception& e) {
76251       {
76252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76253       };
76254     } catch (Dali::DaliException e) {
76255       {
76256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76257       };
76258     } catch (...) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76261       };
76262     }
76263   }
76264
76265   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76266   return jresult;
76267 }
76268
76269
76270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76271   float jresult ;
76272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76273   Dali::Toolkit::ItemId arg2 ;
76274   float result;
76275
76276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76277   arg2 = (Dali::Toolkit::ItemId)jarg2;
76278   {
76279     try {
76280       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76281     } catch (std::out_of_range& e) {
76282       {
76283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76284       };
76285     } catch (std::exception& e) {
76286       {
76287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (Dali::DaliException e) {
76290       {
76291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76292       };
76293     } catch (...) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76296       };
76297     }
76298   }
76299
76300   jresult = result;
76301   return jresult;
76302 }
76303
76304
76305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76307   unsigned int arg2 ;
76308   Dali::Vector3 arg3 ;
76309   float arg4 ;
76310   Dali::Vector3 *argp3 ;
76311
76312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76313   arg2 = (unsigned int)jarg2;
76314   argp3 = (Dali::Vector3 *)jarg3;
76315   if (!argp3) {
76316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76317     return ;
76318   }
76319   arg3 = *argp3;
76320   arg4 = (float)jarg4;
76321   {
76322     try {
76323       (arg1)->ActivateLayout(arg2,arg3,arg4);
76324     } catch (std::out_of_range& e) {
76325       {
76326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76327       };
76328     } catch (std::exception& e) {
76329       {
76330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (Dali::DaliException e) {
76333       {
76334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76335       };
76336     } catch (...) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76339       };
76340     }
76341   }
76342
76343 }
76344
76345
76346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76347   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76348
76349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76350   {
76351     try {
76352       (arg1)->DeactivateCurrentLayout();
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (Dali::DaliException e) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76364       };
76365     } catch (...) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76368       };
76369     }
76370   }
76371
76372 }
76373
76374
76375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76377   float arg2 ;
76378
76379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76380   arg2 = (float)jarg2;
76381   {
76382     try {
76383       (arg1)->SetMinimumSwipeSpeed(arg2);
76384     } catch (std::out_of_range& e) {
76385       {
76386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76387       };
76388     } catch (std::exception& e) {
76389       {
76390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (Dali::DaliException e) {
76393       {
76394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76399       };
76400     }
76401   }
76402
76403 }
76404
76405
76406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76407   float jresult ;
76408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76409   float result;
76410
76411   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76412   {
76413     try {
76414       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76415     } catch (std::out_of_range& e) {
76416       {
76417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76418       };
76419     } catch (std::exception& e) {
76420       {
76421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76422       };
76423     } catch (Dali::DaliException e) {
76424       {
76425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76426       };
76427     } catch (...) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76430       };
76431     }
76432   }
76433
76434   jresult = result;
76435   return jresult;
76436 }
76437
76438
76439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76441   float arg2 ;
76442
76443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76444   arg2 = (float)jarg2;
76445   {
76446     try {
76447       (arg1)->SetMinimumSwipeDistance(arg2);
76448     } catch (std::out_of_range& e) {
76449       {
76450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76451       };
76452     } catch (std::exception& e) {
76453       {
76454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76455       };
76456     } catch (Dali::DaliException e) {
76457       {
76458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76459       };
76460     } catch (...) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76463       };
76464     }
76465   }
76466
76467 }
76468
76469
76470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76471   float jresult ;
76472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76473   float result;
76474
76475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76476   {
76477     try {
76478       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76479     } catch (std::out_of_range& e) {
76480       {
76481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (std::exception& e) {
76484       {
76485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76486       };
76487     } catch (Dali::DaliException e) {
76488       {
76489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76490       };
76491     } catch (...) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76494       };
76495     }
76496   }
76497
76498   jresult = result;
76499   return jresult;
76500 }
76501
76502
76503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76504   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76505   float arg2 ;
76506
76507   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76508   arg2 = (float)jarg2;
76509   {
76510     try {
76511       (arg1)->SetWheelScrollDistanceStep(arg2);
76512     } catch (std::out_of_range& e) {
76513       {
76514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76515       };
76516     } catch (std::exception& e) {
76517       {
76518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76519       };
76520     } catch (Dali::DaliException e) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76523       };
76524     } catch (...) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76527       };
76528     }
76529   }
76530
76531 }
76532
76533
76534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76535   float jresult ;
76536   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76537   float result;
76538
76539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76540   {
76541     try {
76542       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76543     } catch (std::out_of_range& e) {
76544       {
76545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76546       };
76547     } catch (std::exception& e) {
76548       {
76549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (Dali::DaliException e) {
76552       {
76553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76554       };
76555     } catch (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76558       };
76559     }
76560   }
76561
76562   jresult = result;
76563   return jresult;
76564 }
76565
76566
76567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76568   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76569   bool arg2 ;
76570
76571   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76572   arg2 = jarg2 ? true : false;
76573   {
76574     try {
76575       (arg1)->SetAnchoring(arg2);
76576     } catch (std::out_of_range& e) {
76577       {
76578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76579       };
76580     } catch (std::exception& e) {
76581       {
76582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76583       };
76584     } catch (Dali::DaliException e) {
76585       {
76586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76587       };
76588     } catch (...) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76591       };
76592     }
76593   }
76594
76595 }
76596
76597 //// ========================= end of part 3 =============================
76598
76599 //// ========================== start part 4 ===============================
76600
76601
76602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76603   unsigned int jresult ;
76604   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76605   bool result;
76606
76607   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76608   {
76609     try {
76610       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76611     } catch (std::out_of_range& e) {
76612       {
76613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76614       };
76615     } catch (std::exception& e) {
76616       {
76617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76618       };
76619     } catch (Dali::DaliException e) {
76620       {
76621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76622       };
76623     } catch (...) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76626       };
76627     }
76628   }
76629
76630   jresult = result;
76631   return jresult;
76632 }
76633
76634
76635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76636   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76637   float arg2 ;
76638
76639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76640   arg2 = (float)jarg2;
76641   {
76642     try {
76643       (arg1)->SetAnchoringDuration(arg2);
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76659       };
76660     }
76661   }
76662
76663 }
76664
76665
76666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76667   float jresult ;
76668   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76669   float result;
76670
76671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76672   {
76673     try {
76674       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76675     } catch (std::out_of_range& e) {
76676       {
76677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76678       };
76679     } catch (std::exception& e) {
76680       {
76681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (Dali::DaliException e) {
76684       {
76685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76686       };
76687     } catch (...) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76690       };
76691     }
76692   }
76693
76694   jresult = result;
76695   return jresult;
76696 }
76697
76698
76699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76701   Dali::Toolkit::ItemId arg2 ;
76702   float arg3 ;
76703
76704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76705   arg2 = (Dali::Toolkit::ItemId)jarg2;
76706   arg3 = (float)jarg3;
76707   {
76708     try {
76709       (arg1)->ScrollToItem(arg2,arg3);
76710     } catch (std::out_of_range& e) {
76711       {
76712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76713       };
76714     } catch (std::exception& e) {
76715       {
76716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (Dali::DaliException e) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76721       };
76722     } catch (...) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76725       };
76726     }
76727   }
76728
76729 }
76730
76731
76732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76734   float arg2 ;
76735
76736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76737   arg2 = (float)jarg2;
76738   {
76739     try {
76740       (arg1)->SetRefreshInterval(arg2);
76741     } catch (std::out_of_range& e) {
76742       {
76743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (std::exception& e) {
76746       {
76747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76748       };
76749     } catch (Dali::DaliException e) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76752       };
76753     } catch (...) {
76754       {
76755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76756       };
76757     }
76758   }
76759
76760 }
76761
76762
76763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76764   float jresult ;
76765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76766   float result;
76767
76768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76769   {
76770     try {
76771       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76772     } catch (std::out_of_range& e) {
76773       {
76774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76775       };
76776     } catch (std::exception& e) {
76777       {
76778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76779       };
76780     } catch (Dali::DaliException e) {
76781       {
76782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76783       };
76784     } catch (...) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76787       };
76788     }
76789   }
76790
76791   jresult = result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76798
76799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76800   {
76801     try {
76802       (arg1)->Refresh();
76803     } catch (std::out_of_range& e) {
76804       {
76805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76806       };
76807     } catch (std::exception& e) {
76808       {
76809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76810       };
76811     } catch (Dali::DaliException e) {
76812       {
76813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76814       };
76815     } catch (...) {
76816       {
76817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76818       };
76819     }
76820   }
76821
76822 }
76823
76824
76825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76826   void * jresult ;
76827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76828   Dali::Toolkit::ItemId arg2 ;
76829   Dali::Actor result;
76830
76831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76832   arg2 = (Dali::Toolkit::ItemId)jarg2;
76833   {
76834     try {
76835       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76836     } catch (std::out_of_range& e) {
76837       {
76838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76839       };
76840     } catch (std::exception& e) {
76841       {
76842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76843       };
76844     } catch (Dali::DaliException e) {
76845       {
76846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76847       };
76848     } catch (...) {
76849       {
76850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76851       };
76852     }
76853   }
76854
76855   jresult = new Dali::Actor((const Dali::Actor &)result);
76856   return jresult;
76857 }
76858
76859
76860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76861   unsigned int jresult ;
76862   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76863   Dali::Actor arg2 ;
76864   Dali::Actor *argp2 ;
76865   Dali::Toolkit::ItemId result;
76866
76867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76868   argp2 = (Dali::Actor *)jarg2;
76869   if (!argp2) {
76870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76871     return 0;
76872   }
76873   arg2 = *argp2;
76874   {
76875     try {
76876       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76877     } catch (std::out_of_range& e) {
76878       {
76879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76880       };
76881     } catch (std::exception& e) {
76882       {
76883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76884       };
76885     } catch (Dali::DaliException e) {
76886       {
76887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76888       };
76889     } catch (...) {
76890       {
76891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76892       };
76893     }
76894   }
76895
76896   jresult = result;
76897   return jresult;
76898 }
76899
76900
76901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76903   Dali::Toolkit::Item arg2 ;
76904   float arg3 ;
76905   Dali::Toolkit::Item *argp2 ;
76906
76907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76908   argp2 = (Dali::Toolkit::Item *)jarg2;
76909   if (!argp2) {
76910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76911     return ;
76912   }
76913   arg2 = *argp2;
76914   arg3 = (float)jarg3;
76915   {
76916     try {
76917       (arg1)->InsertItem(arg2,arg3);
76918     } catch (std::out_of_range& e) {
76919       {
76920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76921       };
76922     } catch (std::exception& e) {
76923       {
76924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76925       };
76926     } catch (Dali::DaliException e) {
76927       {
76928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76929       };
76930     } catch (...) {
76931       {
76932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76933       };
76934     }
76935   }
76936
76937 }
76938
76939
76940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76942   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76943   float arg3 ;
76944
76945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76946   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76947   if (!arg2) {
76948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76949     return ;
76950   }
76951   arg3 = (float)jarg3;
76952   {
76953     try {
76954       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76955     } catch (std::out_of_range& e) {
76956       {
76957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76958       };
76959     } catch (std::exception& e) {
76960       {
76961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76962       };
76963     } catch (Dali::DaliException e) {
76964       {
76965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76966       };
76967     } catch (...) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76970       };
76971     }
76972   }
76973
76974 }
76975
76976
76977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76978   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76979   Dali::Toolkit::ItemId arg2 ;
76980   float arg3 ;
76981
76982   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76983   arg2 = (Dali::Toolkit::ItemId)jarg2;
76984   arg3 = (float)jarg3;
76985   {
76986     try {
76987       (arg1)->RemoveItem(arg2,arg3);
76988     } catch (std::out_of_range& e) {
76989       {
76990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76991       };
76992     } catch (std::exception& e) {
76993       {
76994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (Dali::DaliException e) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76999       };
77000     } catch (...) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77003       };
77004     }
77005   }
77006
77007 }
77008
77009
77010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77011   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77012   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77013   float arg3 ;
77014
77015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77016   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77017   if (!arg2) {
77018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77019     return ;
77020   }
77021   arg3 = (float)jarg3;
77022   {
77023     try {
77024       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77025     } catch (std::out_of_range& e) {
77026       {
77027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77028       };
77029     } catch (std::exception& e) {
77030       {
77031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77032       };
77033     } catch (Dali::DaliException e) {
77034       {
77035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77036       };
77037     } catch (...) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77040       };
77041     }
77042   }
77043
77044 }
77045
77046
77047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77049   Dali::Toolkit::Item arg2 ;
77050   float arg3 ;
77051   Dali::Toolkit::Item *argp2 ;
77052
77053   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77054   argp2 = (Dali::Toolkit::Item *)jarg2;
77055   if (!argp2) {
77056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77057     return ;
77058   }
77059   arg2 = *argp2;
77060   arg3 = (float)jarg3;
77061   {
77062     try {
77063       (arg1)->ReplaceItem(arg2,arg3);
77064     } catch (std::out_of_range& e) {
77065       {
77066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77067       };
77068     } catch (std::exception& e) {
77069       {
77070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77071       };
77072     } catch (Dali::DaliException e) {
77073       {
77074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77075       };
77076     } catch (...) {
77077       {
77078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77079       };
77080     }
77081   }
77082
77083 }
77084
77085
77086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77087   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77088   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77089   float arg3 ;
77090
77091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77092   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77093   if (!arg2) {
77094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77095     return ;
77096   }
77097   arg3 = (float)jarg3;
77098   {
77099     try {
77100       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77101     } catch (std::out_of_range& e) {
77102       {
77103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77104       };
77105     } catch (std::exception& e) {
77106       {
77107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77108       };
77109     } catch (Dali::DaliException e) {
77110       {
77111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77112       };
77113     } catch (...) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77116       };
77117     }
77118   }
77119
77120 }
77121
77122
77123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77124   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77125   Dali::Vector3 *arg2 = 0 ;
77126
77127   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77128   arg2 = (Dali::Vector3 *)jarg2;
77129   if (!arg2) {
77130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77131     return ;
77132   }
77133   {
77134     try {
77135       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77136     } catch (std::out_of_range& e) {
77137       {
77138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77139       };
77140     } catch (std::exception& e) {
77141       {
77142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77143       };
77144     } catch (Dali::DaliException e) {
77145       {
77146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77147       };
77148     } catch (...) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77151       };
77152     }
77153   }
77154
77155 }
77156
77157
77158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77159   void * jresult ;
77160   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77161   Dali::Vector3 result;
77162
77163   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77164   {
77165     try {
77166       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77167     } catch (std::out_of_range& e) {
77168       {
77169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77170       };
77171     } catch (std::exception& e) {
77172       {
77173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77174       };
77175     } catch (Dali::DaliException e) {
77176       {
77177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77178       };
77179     } catch (...) {
77180       {
77181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77182       };
77183     }
77184   }
77185
77186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77187   return jresult;
77188 }
77189
77190
77191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77192   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77193   Dali::Vector3 *arg2 = 0 ;
77194
77195   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77196   arg2 = (Dali::Vector3 *)jarg2;
77197   if (!arg2) {
77198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77199     return ;
77200   }
77201   {
77202     try {
77203       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77204     } catch (std::out_of_range& e) {
77205       {
77206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77207       };
77208     } catch (std::exception& e) {
77209       {
77210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77211       };
77212     } catch (Dali::DaliException e) {
77213       {
77214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77215       };
77216     } catch (...) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77219       };
77220     }
77221   }
77222
77223 }
77224
77225
77226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77227   void * jresult ;
77228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77229   Dali::Vector3 result;
77230
77231   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77232   {
77233     try {
77234       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77235     } catch (std::out_of_range& e) {
77236       {
77237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (std::exception& e) {
77240       {
77241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (Dali::DaliException e) {
77244       {
77245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77246       };
77247     } catch (...) {
77248       {
77249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77250       };
77251     }
77252   }
77253
77254   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77255   return jresult;
77256 }
77257
77258
77259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77260   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77261   Dali::Toolkit::ItemRange *arg2 = 0 ;
77262
77263   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77264   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77265   if (!arg2) {
77266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77267     return ;
77268   }
77269   {
77270     try {
77271       (arg1)->GetItemsRange(*arg2);
77272     } catch (std::out_of_range& e) {
77273       {
77274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77275       };
77276     } catch (std::exception& e) {
77277       {
77278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77279       };
77280     } catch (Dali::DaliException e) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77287       };
77288     }
77289   }
77290
77291 }
77292
77293
77294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77295   void * jresult ;
77296   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77297   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77298
77299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77300   {
77301     try {
77302       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77303     } catch (std::out_of_range& e) {
77304       {
77305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77306       };
77307     } catch (std::exception& e) {
77308       {
77309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77310       };
77311     } catch (Dali::DaliException e) {
77312       {
77313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77314       };
77315     } catch (...) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77318       };
77319     }
77320   }
77321
77322   jresult = (void *)result;
77323   return jresult;
77324 }
77325
77326
77327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77328   Dali::Vector3 *arg1 = 0 ;
77329   PropertyInputContainer *arg2 = 0 ;
77330
77331   arg1 = (Dali::Vector3 *)jarg1;
77332   if (!arg1) {
77333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77334     return ;
77335   }
77336   arg2 = (PropertyInputContainer *)jarg2;
77337   if (!arg2) {
77338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77339     return ;
77340   }
77341   {
77342     try {
77343       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77344     } catch (std::out_of_range& e) {
77345       {
77346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77347       };
77348     } catch (std::exception& e) {
77349       {
77350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (Dali::DaliException e) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77355       };
77356     } catch (...) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77359       };
77360     }
77361   }
77362
77363 }
77364
77365
77366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77367   Dali::Vector3 *arg1 = 0 ;
77368   PropertyInputContainer *arg2 = 0 ;
77369
77370   arg1 = (Dali::Vector3 *)jarg1;
77371   if (!arg1) {
77372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77373     return ;
77374   }
77375   arg2 = (PropertyInputContainer *)jarg2;
77376   if (!arg2) {
77377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77378     return ;
77379   }
77380   {
77381     try {
77382       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77383     } catch (std::out_of_range& e) {
77384       {
77385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77386       };
77387     } catch (std::exception& e) {
77388       {
77389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77390       };
77391     } catch (Dali::DaliException e) {
77392       {
77393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77394       };
77395     } catch (...) {
77396       {
77397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77398       };
77399     }
77400   }
77401
77402 }
77403
77404
77405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77406   void * jresult ;
77407   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77408
77409   {
77410     try {
77411       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77412     } catch (std::out_of_range& e) {
77413       {
77414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77415       };
77416     } catch (std::exception& e) {
77417       {
77418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77419       };
77420     } catch (Dali::DaliException e) {
77421       {
77422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77423       };
77424     } catch (...) {
77425       {
77426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77427       };
77428     }
77429   }
77430
77431   jresult = (void *)result;
77432   return jresult;
77433 }
77434
77435
77436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77437   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77438
77439   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77440   {
77441     try {
77442       delete arg1;
77443     } catch (std::out_of_range& e) {
77444       {
77445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77446       };
77447     } catch (std::exception& e) {
77448       {
77449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77450       };
77451     } catch (Dali::DaliException e) {
77452       {
77453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77458       };
77459     }
77460   }
77461
77462 }
77463
77464
77465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77466   void * jresult ;
77467   Dali::Path arg1 ;
77468   Dali::Vector3 *arg2 = 0 ;
77469   Dali::Property::Index arg3 ;
77470   Dali::Vector3 *arg4 = 0 ;
77471   unsigned int arg5 ;
77472   Dali::Path *argp1 ;
77473   Dali::Toolkit::ScrollViewPagePathEffect result;
77474
77475   argp1 = (Dali::Path *)jarg1;
77476   if (!argp1) {
77477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77478     return 0;
77479   }
77480   arg1 = *argp1;
77481   arg2 = (Dali::Vector3 *)jarg2;
77482   if (!arg2) {
77483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77484     return 0;
77485   }
77486   arg3 = (Dali::Property::Index)jarg3;
77487   arg4 = (Dali::Vector3 *)jarg4;
77488   if (!arg4) {
77489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77490     return 0;
77491   }
77492   arg5 = (unsigned int)jarg5;
77493   {
77494     try {
77495       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77496     } catch (std::out_of_range& e) {
77497       {
77498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77499       };
77500     } catch (std::exception& e) {
77501       {
77502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77503       };
77504     } catch (Dali::DaliException e) {
77505       {
77506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77507       };
77508     } catch (...) {
77509       {
77510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77511       };
77512     }
77513   }
77514
77515   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77516   return jresult;
77517 }
77518
77519
77520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77521   void * jresult ;
77522   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77523
77524   {
77525     try {
77526       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77527     } catch (std::out_of_range& e) {
77528       {
77529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (std::exception& e) {
77532       {
77533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77534       };
77535     } catch (Dali::DaliException e) {
77536       {
77537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77538       };
77539     } catch (...) {
77540       {
77541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77542       };
77543     }
77544   }
77545
77546   jresult = (void *)result;
77547   return jresult;
77548 }
77549
77550
77551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77552   void * jresult ;
77553   Dali::BaseHandle arg1 ;
77554   Dali::BaseHandle *argp1 ;
77555   Dali::Toolkit::ScrollViewPagePathEffect result;
77556
77557   argp1 = (Dali::BaseHandle *)jarg1;
77558   if (!argp1) {
77559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77560     return 0;
77561   }
77562   arg1 = *argp1;
77563   {
77564     try {
77565       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77566     } catch (std::out_of_range& e) {
77567       {
77568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77569       };
77570     } catch (std::exception& e) {
77571       {
77572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77573       };
77574     } catch (Dali::DaliException e) {
77575       {
77576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77577       };
77578     } catch (...) {
77579       {
77580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77581       };
77582     }
77583   }
77584
77585   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77591   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77592   Dali::Actor arg2 ;
77593   unsigned int arg3 ;
77594   Dali::Actor *argp2 ;
77595
77596   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77597   argp2 = (Dali::Actor *)jarg2;
77598   if (!argp2) {
77599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77600     return ;
77601   }
77602   arg2 = *argp2;
77603   arg3 = (unsigned int)jarg3;
77604   {
77605     try {
77606       (arg1)->ApplyToPage(arg2,arg3);
77607     } catch (std::out_of_range& e) {
77608       {
77609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77610       };
77611     } catch (std::exception& e) {
77612       {
77613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77614       };
77615     } catch (Dali::DaliException e) {
77616       {
77617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77618       };
77619     } catch (...) {
77620       {
77621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77622       };
77623     }
77624   }
77625
77626 }
77627
77628
77629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77630   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77631
77632   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77633   {
77634     try {
77635       delete arg1;
77636     } catch (std::out_of_range& e) {
77637       {
77638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77639       };
77640     } catch (std::exception& e) {
77641       {
77642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77643       };
77644     } catch (Dali::DaliException e) {
77645       {
77646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77647       };
77648     } catch (...) {
77649       {
77650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77651       };
77652     }
77653   }
77654
77655 }
77656
77657
77658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77659   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77660   Dali::Toolkit::ClampState arg2 ;
77661
77662   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77663   arg2 = (Dali::Toolkit::ClampState)jarg2;
77664   if (arg1) (arg1)->x = arg2;
77665 }
77666
77667
77668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77669   int jresult ;
77670   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77671   Dali::Toolkit::ClampState result;
77672
77673   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77674   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77675   jresult = (int)result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77681   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77682   Dali::Toolkit::ClampState arg2 ;
77683
77684   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77685   arg2 = (Dali::Toolkit::ClampState)jarg2;
77686   if (arg1) (arg1)->y = arg2;
77687 }
77688
77689
77690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77691   int jresult ;
77692   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77693   Dali::Toolkit::ClampState result;
77694
77695   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77696   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77697   jresult = (int)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77703   void * jresult ;
77704   Dali::Toolkit::ClampState2D *result = 0 ;
77705
77706   {
77707     try {
77708       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77709     } catch (std::out_of_range& e) {
77710       {
77711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77712       };
77713     } catch (std::exception& e) {
77714       {
77715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77716       };
77717     } catch (Dali::DaliException e) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77724       };
77725     }
77726   }
77727
77728   jresult = (void *)result;
77729   return jresult;
77730 }
77731
77732
77733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77734   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77735
77736   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77737   {
77738     try {
77739       delete arg1;
77740     } catch (std::out_of_range& e) {
77741       {
77742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77743       };
77744     } catch (std::exception& e) {
77745       {
77746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77747       };
77748     } catch (Dali::DaliException e) {
77749       {
77750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77755       };
77756     }
77757   }
77758
77759 }
77760
77761
77762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77763   void * jresult ;
77764   float arg1 ;
77765   float arg2 ;
77766   bool arg3 ;
77767   Dali::Toolkit::RulerDomain *result = 0 ;
77768
77769   arg1 = (float)jarg1;
77770   arg2 = (float)jarg2;
77771   arg3 = jarg3 ? true : false;
77772   {
77773     try {
77774       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
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_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77800   void * jresult ;
77801   float arg1 ;
77802   float arg2 ;
77803   Dali::Toolkit::RulerDomain *result = 0 ;
77804
77805   arg1 = (float)jarg1;
77806   arg2 = (float)jarg2;
77807   {
77808     try {
77809       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77810     } catch (std::out_of_range& e) {
77811       {
77812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77813       };
77814     } catch (std::exception& e) {
77815       {
77816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77817       };
77818     } catch (Dali::DaliException e) {
77819       {
77820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77821       };
77822     } catch (...) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77825       };
77826     }
77827   }
77828
77829   jresult = (void *)result;
77830   return jresult;
77831 }
77832
77833
77834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77835   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77836   float arg2 ;
77837
77838   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77839   arg2 = (float)jarg2;
77840   if (arg1) (arg1)->min = arg2;
77841 }
77842
77843
77844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77845   float jresult ;
77846   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77847   float result;
77848
77849   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77850   result = (float) ((arg1)->min);
77851   jresult = result;
77852   return jresult;
77853 }
77854
77855
77856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77857   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77858   float arg2 ;
77859
77860   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77861   arg2 = (float)jarg2;
77862   if (arg1) (arg1)->max = arg2;
77863 }
77864
77865
77866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77867   float jresult ;
77868   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77869   float result;
77870
77871   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77872   result = (float) ((arg1)->max);
77873   jresult = result;
77874   return jresult;
77875 }
77876
77877
77878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77879   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77880   bool arg2 ;
77881
77882   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77883   arg2 = jarg2 ? true : false;
77884   if (arg1) (arg1)->enabled = arg2;
77885 }
77886
77887
77888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77889   unsigned int jresult ;
77890   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77891   bool result;
77892
77893   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77894   result = (bool) ((arg1)->enabled);
77895   jresult = result;
77896   return jresult;
77897 }
77898
77899
77900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77901   float jresult ;
77902   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77903   float arg2 ;
77904   float arg3 ;
77905   float arg4 ;
77906   float result;
77907
77908   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77909   arg2 = (float)jarg2;
77910   arg3 = (float)jarg3;
77911   arg4 = (float)jarg4;
77912   {
77913     try {
77914       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77915     } catch (std::out_of_range& e) {
77916       {
77917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77918       };
77919     } catch (std::exception& e) {
77920       {
77921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (Dali::DaliException e) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77926       };
77927     } catch (...) {
77928       {
77929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77930       };
77931     }
77932   }
77933
77934   jresult = result;
77935   return jresult;
77936 }
77937
77938
77939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77940   float jresult ;
77941   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77942   float arg2 ;
77943   float arg3 ;
77944   float result;
77945
77946   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77947   arg2 = (float)jarg2;
77948   arg3 = (float)jarg3;
77949   {
77950     try {
77951       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77952     } catch (std::out_of_range& e) {
77953       {
77954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77955       };
77956     } catch (std::exception& e) {
77957       {
77958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77959       };
77960     } catch (Dali::DaliException e) {
77961       {
77962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77963       };
77964     } catch (...) {
77965       {
77966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77967       };
77968     }
77969   }
77970
77971   jresult = result;
77972   return jresult;
77973 }
77974
77975
77976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77977   float jresult ;
77978   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77979   float arg2 ;
77980   float result;
77981
77982   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77983   arg2 = (float)jarg2;
77984   {
77985     try {
77986       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77987     } catch (std::out_of_range& e) {
77988       {
77989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77990       };
77991     } catch (std::exception& e) {
77992       {
77993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (Dali::DaliException e) {
77996       {
77997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77998       };
77999     } catch (...) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78002       };
78003     }
78004   }
78005
78006   jresult = result;
78007   return jresult;
78008 }
78009
78010
78011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78012   float jresult ;
78013   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78014   float arg2 ;
78015   float arg3 ;
78016   float arg4 ;
78017   Dali::Toolkit::ClampState *arg5 = 0 ;
78018   float result;
78019
78020   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78021   arg2 = (float)jarg2;
78022   arg3 = (float)jarg3;
78023   arg4 = (float)jarg4;
78024   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78025   if (!arg5) {
78026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78027     return 0;
78028   }
78029   {
78030     try {
78031       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78032     } catch (std::out_of_range& e) {
78033       {
78034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78035       };
78036     } catch (std::exception& e) {
78037       {
78038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (Dali::DaliException e) {
78041       {
78042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78047       };
78048     }
78049   }
78050
78051   jresult = result;
78052   return jresult;
78053 }
78054
78055
78056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78057   float jresult ;
78058   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78059   float result;
78060
78061   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78062   {
78063     try {
78064       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (Dali::DaliException e) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78076       };
78077     } catch (...) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78080       };
78081     }
78082   }
78083
78084   jresult = result;
78085   return jresult;
78086 }
78087
78088
78089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78090   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78091
78092   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78093   {
78094     try {
78095       delete arg1;
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78103       };
78104     } catch (Dali::DaliException e) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78111       };
78112     }
78113   }
78114
78115 }
78116
78117
78118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78119   float jresult ;
78120   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78121   float arg2 ;
78122   float arg3 ;
78123   float result;
78124
78125   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78126   arg2 = (float)jarg2;
78127   arg3 = (float)jarg3;
78128   {
78129     try {
78130       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78131     } catch (std::out_of_range& e) {
78132       {
78133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78134       };
78135     } catch (std::exception& e) {
78136       {
78137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78138       };
78139     } catch (Dali::DaliException e) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78142       };
78143     } catch (...) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78146       };
78147     }
78148   }
78149
78150   jresult = result;
78151   return jresult;
78152 }
78153
78154
78155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78156   float jresult ;
78157   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78158   float arg2 ;
78159   float result;
78160
78161   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78162   arg2 = (float)jarg2;
78163   {
78164     try {
78165       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78166     } catch (std::out_of_range& e) {
78167       {
78168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78169       };
78170     } catch (std::exception& e) {
78171       {
78172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (Dali::DaliException e) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78177       };
78178     } catch (...) {
78179       {
78180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78181       };
78182     }
78183   }
78184
78185   jresult = result;
78186   return jresult;
78187 }
78188
78189
78190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78191   float jresult ;
78192   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78193   unsigned int arg2 ;
78194   unsigned int *arg3 = 0 ;
78195   bool arg4 ;
78196   float result;
78197
78198   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78199   arg2 = (unsigned int)jarg2;
78200   arg3 = (unsigned int *)jarg3;
78201   arg4 = jarg4 ? true : false;
78202   {
78203     try {
78204       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78205     } catch (std::out_of_range& e) {
78206       {
78207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78208       };
78209     } catch (std::exception& e) {
78210       {
78211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78212       };
78213     } catch (Dali::DaliException e) {
78214       {
78215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78216       };
78217     } catch (...) {
78218       {
78219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78220       };
78221     }
78222   }
78223
78224   jresult = result;
78225   return jresult;
78226 }
78227
78228
78229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78230   unsigned int jresult ;
78231   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78232   float arg2 ;
78233   bool arg3 ;
78234   unsigned int result;
78235
78236   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78237   arg2 = (float)jarg2;
78238   arg3 = jarg3 ? true : false;
78239   {
78240     try {
78241       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78242     } catch (std::out_of_range& e) {
78243       {
78244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78245       };
78246     } catch (std::exception& e) {
78247       {
78248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78249       };
78250     } catch (Dali::DaliException e) {
78251       {
78252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78253       };
78254     } catch (...) {
78255       {
78256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78257       };
78258     }
78259   }
78260
78261   jresult = result;
78262   return jresult;
78263 }
78264
78265
78266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78267   unsigned int jresult ;
78268   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78269   unsigned int result;
78270
78271   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78272   {
78273     try {
78274       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78275     } catch (std::out_of_range& e) {
78276       {
78277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (std::exception& e) {
78280       {
78281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (Dali::DaliException e) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78286       };
78287     } catch (...) {
78288       {
78289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78290       };
78291     }
78292   }
78293
78294   jresult = result;
78295   return jresult;
78296 }
78297
78298
78299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78300   int jresult ;
78301   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78302   Dali::Toolkit::Ruler::RulerType result;
78303
78304   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78305   {
78306     try {
78307       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78308     } catch (std::out_of_range& e) {
78309       {
78310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78311       };
78312     } catch (std::exception& e) {
78313       {
78314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (Dali::DaliException e) {
78317       {
78318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78319       };
78320     } catch (...) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78323       };
78324     }
78325   }
78326
78327   jresult = (int)result;
78328   return jresult;
78329 }
78330
78331
78332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78333   unsigned int jresult ;
78334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78335   bool result;
78336
78337   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78338   {
78339     try {
78340       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78341     } catch (std::out_of_range& e) {
78342       {
78343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78344       };
78345     } catch (std::exception& e) {
78346       {
78347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78348       };
78349     } catch (Dali::DaliException e) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78352       };
78353     } catch (...) {
78354       {
78355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78356       };
78357     }
78358   }
78359
78360   jresult = result;
78361   return jresult;
78362 }
78363
78364
78365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78366   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78367
78368   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78369   {
78370     try {
78371       (arg1)->Enable();
78372     } catch (std::out_of_range& e) {
78373       {
78374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78375       };
78376     } catch (std::exception& e) {
78377       {
78378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78379       };
78380     } catch (Dali::DaliException e) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78387       };
78388     }
78389   }
78390
78391 }
78392
78393
78394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78395   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78396
78397   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78398   {
78399     try {
78400       (arg1)->Disable();
78401     } catch (std::out_of_range& e) {
78402       {
78403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78404       };
78405     } catch (std::exception& e) {
78406       {
78407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78408       };
78409     } catch (Dali::DaliException e) {
78410       {
78411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78412       };
78413     } catch (...) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78416       };
78417     }
78418   }
78419
78420 }
78421
78422
78423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78424   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78425   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78426   Dali::Toolkit::RulerDomain *argp2 ;
78427
78428   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78429   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78430   if (!argp2) {
78431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78432     return ;
78433   }
78434   arg2 = *argp2;
78435   {
78436     try {
78437       (arg1)->SetDomain(arg2);
78438     } catch (std::out_of_range& e) {
78439       {
78440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78441       };
78442     } catch (std::exception& e) {
78443       {
78444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78445       };
78446     } catch (Dali::DaliException e) {
78447       {
78448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78449       };
78450     } catch (...) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78453       };
78454     }
78455   }
78456
78457 }
78458
78459
78460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78461   void * jresult ;
78462   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78463   Dali::Toolkit::RulerDomain *result = 0 ;
78464
78465   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78466   {
78467     try {
78468       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (Dali::DaliException e) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78480       };
78481     } catch (...) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78484       };
78485     }
78486   }
78487
78488   jresult = (void *)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78494   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78495
78496   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78497   {
78498     try {
78499       (arg1)->DisableDomain();
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (Dali::DaliException e) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78515       };
78516     }
78517   }
78518
78519 }
78520
78521
78522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78523   float jresult ;
78524   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78525   float arg2 ;
78526   float arg3 ;
78527   float arg4 ;
78528   float result;
78529
78530   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78531   arg2 = (float)jarg2;
78532   arg3 = (float)jarg3;
78533   arg4 = (float)jarg4;
78534   {
78535     try {
78536       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78537     } catch (std::out_of_range& e) {
78538       {
78539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78540       };
78541     } catch (std::exception& e) {
78542       {
78543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78544       };
78545     } catch (Dali::DaliException e) {
78546       {
78547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78548       };
78549     } catch (...) {
78550       {
78551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78552       };
78553     }
78554   }
78555
78556   jresult = result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78562   float jresult ;
78563   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78564   float arg2 ;
78565   float arg3 ;
78566   float result;
78567
78568   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78569   arg2 = (float)jarg2;
78570   arg3 = (float)jarg3;
78571   {
78572     try {
78573       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78574     } catch (std::out_of_range& e) {
78575       {
78576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78577       };
78578     } catch (std::exception& e) {
78579       {
78580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (Dali::DaliException e) {
78583       {
78584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78585       };
78586     } catch (...) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78589       };
78590     }
78591   }
78592
78593   jresult = result;
78594   return jresult;
78595 }
78596
78597
78598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78599   float jresult ;
78600   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78601   float arg2 ;
78602   float result;
78603
78604   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78605   arg2 = (float)jarg2;
78606   {
78607     try {
78608       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78609     } catch (std::out_of_range& e) {
78610       {
78611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78612       };
78613     } catch (std::exception& e) {
78614       {
78615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (Dali::DaliException e) {
78618       {
78619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78620       };
78621     } catch (...) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78624       };
78625     }
78626   }
78627
78628   jresult = result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78634   float jresult ;
78635   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78636   float arg2 ;
78637   float arg3 ;
78638   float arg4 ;
78639   Dali::Toolkit::ClampState *arg5 = 0 ;
78640   float result;
78641
78642   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78643   arg2 = (float)jarg2;
78644   arg3 = (float)jarg3;
78645   arg4 = (float)jarg4;
78646   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78647   if (!arg5) {
78648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78649     return 0;
78650   }
78651   {
78652     try {
78653       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78654     } catch (std::out_of_range& e) {
78655       {
78656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78657       };
78658     } catch (std::exception& e) {
78659       {
78660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78661       };
78662     } catch (Dali::DaliException e) {
78663       {
78664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78665       };
78666     } catch (...) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78669       };
78670     }
78671   }
78672
78673   jresult = result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78679   float jresult ;
78680   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78681   float arg2 ;
78682   float arg3 ;
78683   float arg4 ;
78684   float arg5 ;
78685   float result;
78686
78687   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78688   arg2 = (float)jarg2;
78689   arg3 = (float)jarg3;
78690   arg4 = (float)jarg4;
78691   arg5 = (float)jarg5;
78692   {
78693     try {
78694       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78695     } catch (std::out_of_range& e) {
78696       {
78697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78698       };
78699     } catch (std::exception& e) {
78700       {
78701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (Dali::DaliException e) {
78704       {
78705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78706       };
78707     } catch (...) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78710       };
78711     }
78712   }
78713
78714   jresult = result;
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78720   float jresult ;
78721   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78722   float arg2 ;
78723   float arg3 ;
78724   float arg4 ;
78725   float result;
78726
78727   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78728   arg2 = (float)jarg2;
78729   arg3 = (float)jarg3;
78730   arg4 = (float)jarg4;
78731   {
78732     try {
78733       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78734     } catch (std::out_of_range& e) {
78735       {
78736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78737       };
78738     } catch (std::exception& e) {
78739       {
78740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78741       };
78742     } catch (Dali::DaliException e) {
78743       {
78744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78745       };
78746     } catch (...) {
78747       {
78748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78749       };
78750     }
78751   }
78752
78753   jresult = result;
78754   return jresult;
78755 }
78756
78757
78758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78759   float jresult ;
78760   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78761   float arg2 ;
78762   float arg3 ;
78763   float result;
78764
78765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78766   arg2 = (float)jarg2;
78767   arg3 = (float)jarg3;
78768   {
78769     try {
78770       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78771     } catch (std::out_of_range& e) {
78772       {
78773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78774       };
78775     } catch (std::exception& e) {
78776       {
78777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (Dali::DaliException e) {
78780       {
78781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78782       };
78783     } catch (...) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78786       };
78787     }
78788   }
78789
78790   jresult = result;
78791   return jresult;
78792 }
78793
78794
78795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78796   float jresult ;
78797   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78798   float arg2 ;
78799   float result;
78800
78801   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78802   arg2 = (float)jarg2;
78803   {
78804     try {
78805       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78806     } catch (std::out_of_range& e) {
78807       {
78808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78809       };
78810     } catch (std::exception& e) {
78811       {
78812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (Dali::DaliException e) {
78815       {
78816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78817       };
78818     } catch (...) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78821       };
78822     }
78823   }
78824
78825   jresult = result;
78826   return jresult;
78827 }
78828
78829
78830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78831   float jresult ;
78832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78833   float arg2 ;
78834   float arg3 ;
78835   float arg4 ;
78836   float arg5 ;
78837   Dali::Toolkit::ClampState *arg6 = 0 ;
78838   float result;
78839
78840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78841   arg2 = (float)jarg2;
78842   arg3 = (float)jarg3;
78843   arg4 = (float)jarg4;
78844   arg5 = (float)jarg5;
78845   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78846   if (!arg6) {
78847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78848     return 0;
78849   }
78850   {
78851     try {
78852       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78853     } catch (std::out_of_range& e) {
78854       {
78855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (std::exception& e) {
78858       {
78859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78860       };
78861     } catch (Dali::DaliException e) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78864       };
78865     } catch (...) {
78866       {
78867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78868       };
78869     }
78870   }
78871
78872   jresult = result;
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78878   void * jresult ;
78879   Dali::Toolkit::DefaultRuler *result = 0 ;
78880
78881   {
78882     try {
78883       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78884     } catch (std::out_of_range& e) {
78885       {
78886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78887       };
78888     } catch (std::exception& e) {
78889       {
78890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78891       };
78892     } catch (Dali::DaliException e) {
78893       {
78894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78895       };
78896     } catch (...) {
78897       {
78898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78899       };
78900     }
78901   }
78902
78903   jresult = (void *)result;
78904   return jresult;
78905 }
78906
78907
78908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78909   float jresult ;
78910   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78911   float arg2 ;
78912   float arg3 ;
78913   float result;
78914
78915   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78916   arg2 = (float)jarg2;
78917   arg3 = (float)jarg3;
78918   {
78919     try {
78920       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78921     } catch (std::out_of_range& e) {
78922       {
78923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78924       };
78925     } catch (std::exception& e) {
78926       {
78927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (Dali::DaliException e) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78932       };
78933     } catch (...) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78936       };
78937     }
78938   }
78939
78940   jresult = result;
78941   return jresult;
78942 }
78943
78944
78945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78946   float jresult ;
78947   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78948   unsigned int arg2 ;
78949   unsigned int *arg3 = 0 ;
78950   bool arg4 ;
78951   float result;
78952
78953   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78954   arg2 = (unsigned int)jarg2;
78955   arg3 = (unsigned int *)jarg3;
78956   arg4 = jarg4 ? true : false;
78957   {
78958     try {
78959       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78960     } catch (std::out_of_range& e) {
78961       {
78962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78963       };
78964     } catch (std::exception& e) {
78965       {
78966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78967       };
78968     } catch (Dali::DaliException e) {
78969       {
78970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78971       };
78972     } catch (...) {
78973       {
78974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78975       };
78976     }
78977   }
78978
78979   jresult = result;
78980   return jresult;
78981 }
78982
78983
78984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78985   unsigned int jresult ;
78986   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78987   float arg2 ;
78988   bool arg3 ;
78989   unsigned int result;
78990
78991   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78992   arg2 = (float)jarg2;
78993   arg3 = jarg3 ? true : false;
78994   {
78995     try {
78996       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78997     } catch (std::out_of_range& e) {
78998       {
78999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79000       };
79001     } catch (std::exception& e) {
79002       {
79003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79004       };
79005     } catch (Dali::DaliException e) {
79006       {
79007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79008       };
79009     } catch (...) {
79010       {
79011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79012       };
79013     }
79014   }
79015
79016   jresult = result;
79017   return jresult;
79018 }
79019
79020
79021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79022   unsigned int jresult ;
79023   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79024   unsigned int result;
79025
79026   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79027   {
79028     try {
79029       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79030     } catch (std::out_of_range& e) {
79031       {
79032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79033       };
79034     } catch (std::exception& e) {
79035       {
79036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (Dali::DaliException e) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79045       };
79046     }
79047   }
79048
79049   jresult = result;
79050   return jresult;
79051 }
79052
79053
79054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79055   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79056
79057   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79058   {
79059     try {
79060       delete arg1;
79061     } catch (std::out_of_range& e) {
79062       {
79063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79064       };
79065     } catch (std::exception& e) {
79066       {
79067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79068       };
79069     } catch (Dali::DaliException e) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79072       };
79073     } catch (...) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79076       };
79077     }
79078   }
79079
79080 }
79081
79082
79083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79084   void * jresult ;
79085   float arg1 ;
79086   Dali::Toolkit::FixedRuler *result = 0 ;
79087
79088   arg1 = (float)jarg1;
79089   {
79090     try {
79091       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79092     } catch (std::out_of_range& e) {
79093       {
79094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (std::exception& e) {
79097       {
79098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79099       };
79100     } catch (Dali::DaliException e) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79103       };
79104     } catch (...) {
79105       {
79106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79107       };
79108     }
79109   }
79110
79111   jresult = (void *)result;
79112   return jresult;
79113 }
79114
79115
79116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79117   void * jresult ;
79118   Dali::Toolkit::FixedRuler *result = 0 ;
79119
79120   {
79121     try {
79122       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (Dali::DaliException e) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79134       };
79135     } catch (...) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79138       };
79139     }
79140   }
79141
79142   jresult = (void *)result;
79143   return jresult;
79144 }
79145
79146
79147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79148   float jresult ;
79149   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79150   float arg2 ;
79151   float arg3 ;
79152   float result;
79153
79154   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79155   arg2 = (float)jarg2;
79156   arg3 = (float)jarg3;
79157   {
79158     try {
79159       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79160     } catch (std::out_of_range& e) {
79161       {
79162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79163       };
79164     } catch (std::exception& e) {
79165       {
79166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79167       };
79168     } catch (Dali::DaliException e) {
79169       {
79170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79171       };
79172     } catch (...) {
79173       {
79174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79175       };
79176     }
79177   }
79178
79179   jresult = result;
79180   return jresult;
79181 }
79182
79183
79184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79185   float jresult ;
79186   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79187   unsigned int arg2 ;
79188   unsigned int *arg3 = 0 ;
79189   bool arg4 ;
79190   float result;
79191
79192   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79193   arg2 = (unsigned int)jarg2;
79194   arg3 = (unsigned int *)jarg3;
79195   arg4 = jarg4 ? true : false;
79196   {
79197     try {
79198       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79199     } catch (std::out_of_range& e) {
79200       {
79201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79202       };
79203     } catch (std::exception& e) {
79204       {
79205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79206       };
79207     } catch (Dali::DaliException e) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79210       };
79211     } catch (...) {
79212       {
79213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79214       };
79215     }
79216   }
79217
79218   jresult = result;
79219   return jresult;
79220 }
79221
79222
79223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79224   unsigned int jresult ;
79225   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79226   float arg2 ;
79227   bool arg3 ;
79228   unsigned int result;
79229
79230   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79231   arg2 = (float)jarg2;
79232   arg3 = jarg3 ? true : false;
79233   {
79234     try {
79235       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79236     } catch (std::out_of_range& e) {
79237       {
79238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79239       };
79240     } catch (std::exception& e) {
79241       {
79242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79243       };
79244     } catch (Dali::DaliException e) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79247       };
79248     } catch (...) {
79249       {
79250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79251       };
79252     }
79253   }
79254
79255   jresult = result;
79256   return jresult;
79257 }
79258
79259
79260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79261   unsigned int jresult ;
79262   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79263   unsigned int result;
79264
79265   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79266   {
79267     try {
79268       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79269     } catch (std::out_of_range& e) {
79270       {
79271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79272       };
79273     } catch (std::exception& e) {
79274       {
79275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79276       };
79277     } catch (Dali::DaliException e) {
79278       {
79279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79280       };
79281     } catch (...) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79284       };
79285     }
79286   }
79287
79288   jresult = result;
79289   return jresult;
79290 }
79291
79292
79293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79294   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79295
79296   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79297   {
79298     try {
79299       delete arg1;
79300     } catch (std::out_of_range& e) {
79301       {
79302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79303       };
79304     } catch (std::exception& e) {
79305       {
79306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79307       };
79308     } catch (Dali::DaliException e) {
79309       {
79310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79311       };
79312     } catch (...) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79315       };
79316     }
79317   }
79318
79319 }
79320
79321
79322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79323   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79324   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79325
79326   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79327   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79328   if (arg1) (arg1)->scale = *arg2;
79329 }
79330
79331
79332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79333   void * jresult ;
79334   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79335   Dali::Toolkit::ClampState2D *result = 0 ;
79336
79337   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79338   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79339   jresult = (void *)result;
79340   return jresult;
79341 }
79342
79343
79344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79345   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79346   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79347
79348   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79349   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79350   if (arg1) (arg1)->position = *arg2;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79355   void * jresult ;
79356   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79357   Dali::Toolkit::ClampState2D *result = 0 ;
79358
79359   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79360   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79361   jresult = (void *)result;
79362   return jresult;
79363 }
79364
79365
79366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79367   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79368   Dali::Toolkit::ClampState arg2 ;
79369
79370   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79371   arg2 = (Dali::Toolkit::ClampState)jarg2;
79372   if (arg1) (arg1)->rotation = arg2;
79373 }
79374
79375
79376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79377   int jresult ;
79378   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79379   Dali::Toolkit::ClampState result;
79380
79381   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79382   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79383   jresult = (int)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79389   void * jresult ;
79390   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79391
79392   {
79393     try {
79394       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (Dali::DaliException e) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79406       };
79407     } catch (...) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79410       };
79411     }
79412   }
79413
79414   jresult = (void *)result;
79415   return jresult;
79416 }
79417
79418
79419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79420   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79421
79422   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79423   {
79424     try {
79425       delete arg1;
79426     } catch (std::out_of_range& e) {
79427       {
79428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79429       };
79430     } catch (std::exception& e) {
79431       {
79432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (Dali::DaliException e) {
79435       {
79436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79437       };
79438     } catch (...) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79441       };
79442     }
79443   }
79444
79445 }
79446
79447
79448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79449   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79450   Dali::Toolkit::SnapType arg2 ;
79451
79452   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79453   arg2 = (Dali::Toolkit::SnapType)jarg2;
79454   if (arg1) (arg1)->type = arg2;
79455 }
79456
79457
79458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79459   int jresult ;
79460   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79461   Dali::Toolkit::SnapType result;
79462
79463   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79464   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79465   jresult = (int)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79471   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79472   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79473
79474   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79475   arg2 = (Dali::Vector2 *)jarg2;
79476   if (arg1) (arg1)->position = *arg2;
79477 }
79478
79479
79480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79481   void * jresult ;
79482   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79483   Dali::Vector2 *result = 0 ;
79484
79485   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79486   result = (Dali::Vector2 *)& ((arg1)->position);
79487   jresult = (void *)result;
79488   return jresult;
79489 }
79490
79491
79492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79493   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79494   float arg2 ;
79495
79496   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79497   arg2 = (float)jarg2;
79498   if (arg1) (arg1)->duration = arg2;
79499 }
79500
79501
79502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79503   float jresult ;
79504   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79505   float result;
79506
79507   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79508   result = (float) ((arg1)->duration);
79509   jresult = result;
79510   return jresult;
79511 }
79512
79513
79514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79515   void * jresult ;
79516   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79517
79518   {
79519     try {
79520       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79521     } catch (std::out_of_range& e) {
79522       {
79523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79524       };
79525     } catch (std::exception& e) {
79526       {
79527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (Dali::DaliException e) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79532       };
79533     } catch (...) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79536       };
79537     }
79538   }
79539
79540   jresult = (void *)result;
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79546   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79547
79548   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79549   {
79550     try {
79551       delete arg1;
79552     } catch (std::out_of_range& e) {
79553       {
79554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79555       };
79556     } catch (std::exception& e) {
79557       {
79558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79559       };
79560     } catch (Dali::DaliException e) {
79561       {
79562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79563       };
79564     } catch (...) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79567       };
79568     }
79569   }
79570
79571 }
79572
79573
79574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79575   int jresult ;
79576   int result;
79577
79578   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79579   jresult = (int)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79585   int jresult ;
79586   int result;
79587
79588   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79589   jresult = (int)result;
79590   return jresult;
79591 }
79592
79593
79594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79595   int jresult ;
79596   int result;
79597
79598   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79599   jresult = (int)result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79605   int jresult ;
79606   int result;
79607
79608   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79609   jresult = (int)result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79615   int jresult ;
79616   int result;
79617
79618   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79619   jresult = (int)result;
79620   return jresult;
79621 }
79622
79623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79624   int jresult ;
79625   int result;
79626
79627   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79628   jresult = (int)result;
79629   return jresult;
79630 }
79631
79632
79633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79634   int jresult ;
79635   int result;
79636
79637   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79638   jresult = (int)result;
79639   return jresult;
79640 }
79641
79642
79643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79644   int jresult ;
79645   int result;
79646
79647   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79648   jresult = (int)result;
79649   return jresult;
79650 }
79651
79652
79653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79654   int jresult ;
79655   int result;
79656
79657   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79658   jresult = (int)result;
79659   return jresult;
79660 }
79661
79662
79663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79664   int jresult ;
79665   int result;
79666
79667   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79668   jresult = (int)result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79674   int jresult ;
79675   int result;
79676
79677   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79678   jresult = (int)result;
79679   return jresult;
79680 }
79681
79682
79683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79684   int jresult ;
79685   int result;
79686
79687   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79688   jresult = (int)result;
79689   return jresult;
79690 }
79691
79692
79693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79694   int jresult ;
79695   int result;
79696
79697   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79698   jresult = (int)result;
79699   return jresult;
79700 }
79701
79702
79703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79704   int jresult ;
79705   int result;
79706
79707   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79708   jresult = (int)result;
79709   return jresult;
79710 }
79711
79712
79713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79714   int jresult ;
79715   int result;
79716
79717   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79718   jresult = (int)result;
79719   return jresult;
79720 }
79721
79722
79723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79724   int jresult ;
79725   int result;
79726
79727   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79728   jresult = (int)result;
79729   return jresult;
79730 }
79731
79732
79733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79734   int jresult ;
79735   int result;
79736
79737   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79738   jresult = (int)result;
79739   return jresult;
79740 }
79741
79742
79743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79744   int jresult ;
79745   int result;
79746
79747   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79748   jresult = (int)result;
79749   return jresult;
79750 }
79751
79752
79753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79754   int jresult ;
79755   int result;
79756
79757   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79758   jresult = (int)result;
79759   return jresult;
79760 }
79761
79762
79763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79764   int jresult ;
79765   int result;
79766
79767   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79768   jresult = (int)result;
79769   return jresult;
79770 }
79771
79772
79773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79774   int jresult ;
79775   int result;
79776
79777   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79778   jresult = (int)result;
79779   return jresult;
79780 }
79781
79782
79783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79784   int jresult ;
79785   int result;
79786
79787   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79788   jresult = (int)result;
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79794   int jresult ;
79795   int result;
79796
79797   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79798   jresult = (int)result;
79799   return jresult;
79800 }
79801
79802
79803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79804   int jresult ;
79805   int result;
79806
79807   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79808   jresult = (int)result;
79809   return jresult;
79810 }
79811
79812
79813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79814   int jresult ;
79815   int result;
79816
79817   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79818   jresult = (int)result;
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79824   int jresult ;
79825   int result;
79826
79827   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79828   jresult = (int)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79834   void * jresult ;
79835   Dali::Toolkit::ScrollView::Property *result = 0 ;
79836
79837   {
79838     try {
79839       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79840     } catch (std::out_of_range& e) {
79841       {
79842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79843       };
79844     } catch (std::exception& e) {
79845       {
79846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (Dali::DaliException e) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79851       };
79852     } catch (...) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79855       };
79856     }
79857   }
79858
79859   jresult = (void *)result;
79860   return jresult;
79861 }
79862
79863
79864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79865   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79866
79867   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79868   {
79869     try {
79870       delete arg1;
79871     } catch (std::out_of_range& e) {
79872       {
79873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79874       };
79875     } catch (std::exception& e) {
79876       {
79877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79878       };
79879     } catch (Dali::DaliException e) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79882       };
79883     } catch (...) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79886       };
79887     }
79888   }
79889
79890 }
79891
79892
79893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79894   void * jresult ;
79895   Dali::Toolkit::ScrollView *result = 0 ;
79896
79897   {
79898     try {
79899       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79900     } catch (std::out_of_range& e) {
79901       {
79902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (std::exception& e) {
79905       {
79906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79907       };
79908     } catch (Dali::DaliException e) {
79909       {
79910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79911       };
79912     } catch (...) {
79913       {
79914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79915       };
79916     }
79917   }
79918
79919   jresult = (void *)result;
79920   return jresult;
79921 }
79922
79923
79924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79925   void * jresult ;
79926   Dali::Toolkit::ScrollView *arg1 = 0 ;
79927   Dali::Toolkit::ScrollView *result = 0 ;
79928
79929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79930   if (!arg1) {
79931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79932     return 0;
79933   }
79934   {
79935     try {
79936       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (Dali::DaliException e) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79948       };
79949     } catch (...) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79952       };
79953     }
79954   }
79955
79956   jresult = (void *)result;
79957   return jresult;
79958 }
79959
79960
79961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79962   void * jresult ;
79963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79964   Dali::Toolkit::ScrollView *arg2 = 0 ;
79965   Dali::Toolkit::ScrollView *result = 0 ;
79966
79967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79968   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79969   if (!arg2) {
79970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79971     return 0;
79972   }
79973   {
79974     try {
79975       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79976     } catch (std::out_of_range& e) {
79977       {
79978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79979       };
79980     } catch (std::exception& e) {
79981       {
79982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79983       };
79984     } catch (Dali::DaliException e) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79987       };
79988     } catch (...) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79991       };
79992     }
79993   }
79994
79995   jresult = (void *)result;
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80002
80003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80004   {
80005     try {
80006       delete arg1;
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80014       };
80015     } catch (Dali::DaliException e) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80018       };
80019     } catch (...) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80022       };
80023     }
80024   }
80025
80026 }
80027
80028
80029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80030   void * jresult ;
80031   Dali::Toolkit::ScrollView result;
80032
80033   {
80034     try {
80035       result = Dali::Toolkit::ScrollView::New();
80036     } catch (std::out_of_range& e) {
80037       {
80038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80039       };
80040     } catch (std::exception& e) {
80041       {
80042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80043       };
80044     } catch (Dali::DaliException e) {
80045       {
80046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80047       };
80048     } catch (...) {
80049       {
80050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80051       };
80052     }
80053   }
80054
80055   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80056   return jresult;
80057 }
80058
80059
80060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80061   void * jresult ;
80062   Dali::BaseHandle arg1 ;
80063   Dali::BaseHandle *argp1 ;
80064   Dali::Toolkit::ScrollView result;
80065
80066   argp1 = (Dali::BaseHandle *)jarg1;
80067   if (!argp1) {
80068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80069     return 0;
80070   }
80071   arg1 = *argp1;
80072   {
80073     try {
80074       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80075     } catch (std::out_of_range& e) {
80076       {
80077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (std::exception& e) {
80080       {
80081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (Dali::DaliException e) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80086       };
80087     } catch (...) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80090       };
80091     }
80092   }
80093
80094   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80095   return jresult;
80096 }
80097
80098
80099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80100   void * jresult ;
80101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80102   Dali::AlphaFunction result;
80103
80104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80105   {
80106     try {
80107       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80115       };
80116     } catch (Dali::DaliException e) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80119       };
80120     } catch (...) {
80121       {
80122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80123       };
80124     }
80125   }
80126
80127   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80128   return jresult;
80129 }
80130
80131
80132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80134   Dali::AlphaFunction arg2 ;
80135   Dali::AlphaFunction *argp2 ;
80136
80137   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80138   argp2 = (Dali::AlphaFunction *)jarg2;
80139   if (!argp2) {
80140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80141     return ;
80142   }
80143   arg2 = *argp2;
80144   {
80145     try {
80146       (arg1)->SetScrollSnapAlphaFunction(arg2);
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (Dali::DaliException e) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80162       };
80163     }
80164   }
80165
80166 }
80167
80168
80169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80170   void * jresult ;
80171   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80172   Dali::AlphaFunction result;
80173
80174   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80175   {
80176     try {
80177       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80178     } catch (std::out_of_range& e) {
80179       {
80180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80181       };
80182     } catch (std::exception& e) {
80183       {
80184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80185       };
80186     } catch (Dali::DaliException e) {
80187       {
80188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80189       };
80190     } catch (...) {
80191       {
80192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80193       };
80194     }
80195   }
80196
80197   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80198   return jresult;
80199 }
80200
80201
80202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80203   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80204   Dali::AlphaFunction arg2 ;
80205   Dali::AlphaFunction *argp2 ;
80206
80207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80208   argp2 = (Dali::AlphaFunction *)jarg2;
80209   if (!argp2) {
80210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80211     return ;
80212   }
80213   arg2 = *argp2;
80214   {
80215     try {
80216       (arg1)->SetScrollFlickAlphaFunction(arg2);
80217     } catch (std::out_of_range& e) {
80218       {
80219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80220       };
80221     } catch (std::exception& e) {
80222       {
80223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80224       };
80225     } catch (Dali::DaliException e) {
80226       {
80227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80228       };
80229     } catch (...) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80232       };
80233     }
80234   }
80235
80236 }
80237
80238
80239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80240   float jresult ;
80241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80242   float result;
80243
80244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80245   {
80246     try {
80247       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80248     } catch (std::out_of_range& e) {
80249       {
80250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80251       };
80252     } catch (std::exception& e) {
80253       {
80254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80255       };
80256     } catch (Dali::DaliException e) {
80257       {
80258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80259       };
80260     } catch (...) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80263       };
80264     }
80265   }
80266
80267   jresult = result;
80268   return jresult;
80269 }
80270
80271
80272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80274   float arg2 ;
80275
80276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80277   arg2 = (float)jarg2;
80278   {
80279     try {
80280       (arg1)->SetScrollSnapDuration(arg2);
80281     } catch (std::out_of_range& e) {
80282       {
80283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80284       };
80285     } catch (std::exception& e) {
80286       {
80287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80288       };
80289     } catch (Dali::DaliException e) {
80290       {
80291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80292       };
80293     } catch (...) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80296       };
80297     }
80298   }
80299
80300 }
80301
80302
80303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80304   float jresult ;
80305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80306   float result;
80307
80308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80309   {
80310     try {
80311       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80312     } catch (std::out_of_range& e) {
80313       {
80314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80315       };
80316     } catch (std::exception& e) {
80317       {
80318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80319       };
80320     } catch (Dali::DaliException e) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80323       };
80324     } catch (...) {
80325       {
80326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80327       };
80328     }
80329   }
80330
80331   jresult = result;
80332   return jresult;
80333 }
80334
80335
80336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80338   float arg2 ;
80339
80340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80341   arg2 = (float)jarg2;
80342   {
80343     try {
80344       (arg1)->SetScrollFlickDuration(arg2);
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80352       };
80353     } catch (Dali::DaliException e) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80360       };
80361     }
80362   }
80363
80364 }
80365
80366
80367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80369   Dali::Toolkit::RulerPtr arg2 ;
80370   Dali::Toolkit::RulerPtr *argp2 ;
80371
80372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80373   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80374   if (!argp2) {
80375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80376     return ;
80377   }
80378   arg2 = *argp2;
80379   {
80380     try {
80381       (arg1)->SetRulerX(arg2);
80382     } catch (std::out_of_range& e) {
80383       {
80384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80385       };
80386     } catch (std::exception& e) {
80387       {
80388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80389       };
80390     } catch (Dali::DaliException e) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80393       };
80394     } catch (...) {
80395       {
80396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80397       };
80398     }
80399   }
80400
80401 }
80402
80403
80404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80406   Dali::Toolkit::RulerPtr arg2 ;
80407   Dali::Toolkit::RulerPtr *argp2 ;
80408
80409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80410   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80411   if (!argp2) {
80412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80413     return ;
80414   }
80415   arg2 = *argp2;
80416   {
80417     try {
80418       (arg1)->SetRulerY(arg2);
80419     } catch (std::out_of_range& e) {
80420       {
80421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80422       };
80423     } catch (std::exception& e) {
80424       {
80425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (Dali::DaliException e) {
80428       {
80429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80430       };
80431     } catch (...) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80434       };
80435     }
80436   }
80437
80438 }
80439
80440
80441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80443   bool arg2 ;
80444
80445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80446   arg2 = jarg2 ? true : false;
80447   {
80448     try {
80449       (arg1)->SetScrollSensitive(arg2);
80450     } catch (std::out_of_range& e) {
80451       {
80452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80453       };
80454     } catch (std::exception& e) {
80455       {
80456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80457       };
80458     } catch (Dali::DaliException e) {
80459       {
80460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80461       };
80462     } catch (...) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80465       };
80466     }
80467   }
80468
80469 }
80470
80471
80472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80473   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80474   float arg2 ;
80475   float arg3 ;
80476
80477   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80478   arg2 = (float)jarg2;
80479   arg3 = (float)jarg3;
80480   {
80481     try {
80482       (arg1)->SetMaxOvershoot(arg2,arg3);
80483     } catch (std::out_of_range& e) {
80484       {
80485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80486       };
80487     } catch (std::exception& e) {
80488       {
80489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80490       };
80491     } catch (Dali::DaliException e) {
80492       {
80493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80494       };
80495     } catch (...) {
80496       {
80497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80498       };
80499     }
80500   }
80501
80502 }
80503
80504
80505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80506   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80507   Dali::AlphaFunction arg2 ;
80508   Dali::AlphaFunction *argp2 ;
80509
80510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80511   argp2 = (Dali::AlphaFunction *)jarg2;
80512   if (!argp2) {
80513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80514     return ;
80515   }
80516   arg2 = *argp2;
80517   {
80518     try {
80519       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80520     } catch (std::out_of_range& e) {
80521       {
80522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80523       };
80524     } catch (std::exception& e) {
80525       {
80526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80527       };
80528     } catch (Dali::DaliException e) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80531       };
80532     } catch (...) {
80533       {
80534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80535       };
80536     }
80537   }
80538
80539 }
80540
80541
80542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80544   float arg2 ;
80545
80546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80547   arg2 = (float)jarg2;
80548   {
80549     try {
80550       (arg1)->SetSnapOvershootDuration(arg2);
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80566       };
80567     }
80568   }
80569
80570 }
80571
80572
80573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80575   bool arg2 ;
80576
80577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80578   arg2 = jarg2 ? true : false;
80579   {
80580     try {
80581       (arg1)->SetActorAutoSnap(arg2);
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80597       };
80598     }
80599   }
80600
80601 }
80602
80603
80604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   bool arg2 ;
80607
80608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80609   arg2 = jarg2 ? true : false;
80610   {
80611     try {
80612       (arg1)->SetWrapMode(arg2);
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80620       };
80621     } catch (Dali::DaliException e) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80624       };
80625     } catch (...) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80628       };
80629     }
80630   }
80631
80632 }
80633
80634
80635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80636   int jresult ;
80637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80638   int result;
80639
80640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80641   {
80642     try {
80643       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80644     } catch (std::out_of_range& e) {
80645       {
80646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80647       };
80648     } catch (std::exception& e) {
80649       {
80650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80651       };
80652     } catch (Dali::DaliException e) {
80653       {
80654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80655       };
80656     } catch (...) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80659       };
80660     }
80661   }
80662
80663   jresult = result;
80664   return jresult;
80665 }
80666
80667
80668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   int arg2 ;
80671
80672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80673   arg2 = (int)jarg2;
80674   {
80675     try {
80676       (arg1)->SetScrollUpdateDistance(arg2);
80677     } catch (std::out_of_range& e) {
80678       {
80679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80680       };
80681     } catch (std::exception& e) {
80682       {
80683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80684       };
80685     } catch (Dali::DaliException e) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80688       };
80689     } catch (...) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80692       };
80693     }
80694   }
80695
80696 }
80697
80698
80699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80700   unsigned int jresult ;
80701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80702   bool result;
80703
80704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80705   {
80706     try {
80707       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80708     } catch (std::out_of_range& e) {
80709       {
80710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80711       };
80712     } catch (std::exception& e) {
80713       {
80714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80715       };
80716     } catch (Dali::DaliException e) {
80717       {
80718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80719       };
80720     } catch (...) {
80721       {
80722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80723       };
80724     }
80725   }
80726
80727   jresult = result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80734   bool arg2 ;
80735
80736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80737   arg2 = jarg2 ? true : false;
80738   {
80739     try {
80740       (arg1)->SetAxisAutoLock(arg2);
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80748       };
80749     } catch (Dali::DaliException e) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80752       };
80753     } catch (...) {
80754       {
80755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80756       };
80757     }
80758   }
80759
80760 }
80761
80762
80763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80764   float jresult ;
80765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80766   float result;
80767
80768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80769   {
80770     try {
80771       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80772     } catch (std::out_of_range& e) {
80773       {
80774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80775       };
80776     } catch (std::exception& e) {
80777       {
80778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (Dali::DaliException e) {
80781       {
80782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80783       };
80784     } catch (...) {
80785       {
80786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80787       };
80788     }
80789   }
80790
80791   jresult = result;
80792   return jresult;
80793 }
80794
80795
80796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80798   float arg2 ;
80799
80800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80801   arg2 = (float)jarg2;
80802   {
80803     try {
80804       (arg1)->SetAxisAutoLockGradient(arg2);
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80812       };
80813     } catch (Dali::DaliException e) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80816       };
80817     } catch (...) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80820       };
80821     }
80822   }
80823
80824 }
80825
80826
80827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80828   float jresult ;
80829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80830   float result;
80831
80832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80833   {
80834     try {
80835       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80836     } catch (std::out_of_range& e) {
80837       {
80838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80839       };
80840     } catch (std::exception& e) {
80841       {
80842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80843       };
80844     } catch (Dali::DaliException e) {
80845       {
80846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80847       };
80848     } catch (...) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80851       };
80852     }
80853   }
80854
80855   jresult = result;
80856   return jresult;
80857 }
80858
80859
80860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80861   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80862   float arg2 ;
80863
80864   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80865   arg2 = (float)jarg2;
80866   {
80867     try {
80868       (arg1)->SetFrictionCoefficient(arg2);
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80876       };
80877     } catch (Dali::DaliException e) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80880       };
80881     } catch (...) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80884       };
80885     }
80886   }
80887
80888 }
80889
80890
80891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80892   float jresult ;
80893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80894   float result;
80895
80896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80897   {
80898     try {
80899       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80900     } catch (std::out_of_range& e) {
80901       {
80902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80903       };
80904     } catch (std::exception& e) {
80905       {
80906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80907       };
80908     } catch (Dali::DaliException e) {
80909       {
80910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80911       };
80912     } catch (...) {
80913       {
80914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80915       };
80916     }
80917   }
80918
80919   jresult = result;
80920   return jresult;
80921 }
80922
80923
80924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80926   float arg2 ;
80927
80928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80929   arg2 = (float)jarg2;
80930   {
80931     try {
80932       (arg1)->SetFlickSpeedCoefficient(arg2);
80933     } catch (std::out_of_range& e) {
80934       {
80935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80936       };
80937     } catch (std::exception& e) {
80938       {
80939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80940       };
80941     } catch (Dali::DaliException e) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80948       };
80949     }
80950   }
80951
80952 }
80953
80954
80955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80956   void * jresult ;
80957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80958   Dali::Vector2 result;
80959
80960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80961   {
80962     try {
80963       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80964     } catch (std::out_of_range& e) {
80965       {
80966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80967       };
80968     } catch (std::exception& e) {
80969       {
80970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80971       };
80972     } catch (Dali::DaliException e) {
80973       {
80974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80979       };
80980     }
80981   }
80982
80983   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80984   return jresult;
80985 }
80986
80987
80988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80989   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80990   Dali::Vector2 *arg2 = 0 ;
80991
80992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80993   arg2 = (Dali::Vector2 *)jarg2;
80994   if (!arg2) {
80995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80996     return ;
80997   }
80998   {
80999     try {
81000       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81008       };
81009     } catch (Dali::DaliException e) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81012       };
81013     } catch (...) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81016       };
81017     }
81018   }
81019
81020 }
81021
81022
81023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81024   float jresult ;
81025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81026   float result;
81027
81028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81029   {
81030     try {
81031       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81032     } catch (std::out_of_range& e) {
81033       {
81034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81035       };
81036     } catch (std::exception& e) {
81037       {
81038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (Dali::DaliException e) {
81041       {
81042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81043       };
81044     } catch (...) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81047       };
81048     }
81049   }
81050
81051   jresult = result;
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81057   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81058   float arg2 ;
81059
81060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81061   arg2 = (float)jarg2;
81062   {
81063     try {
81064       (arg1)->SetMinimumSpeedForFlick(arg2);
81065     } catch (std::out_of_range& e) {
81066       {
81067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81068       };
81069     } catch (std::exception& e) {
81070       {
81071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81072       };
81073     } catch (Dali::DaliException e) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81076       };
81077     } catch (...) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81080       };
81081     }
81082   }
81083
81084 }
81085
81086
81087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81088   float jresult ;
81089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81090   float result;
81091
81092   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81093   {
81094     try {
81095       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81096     } catch (std::out_of_range& e) {
81097       {
81098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81099       };
81100     } catch (std::exception& e) {
81101       {
81102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81103       };
81104     } catch (Dali::DaliException e) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81107       };
81108     } catch (...) {
81109       {
81110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81111       };
81112     }
81113   }
81114
81115   jresult = result;
81116   return jresult;
81117 }
81118
81119
81120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81122   float arg2 ;
81123
81124   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81125   arg2 = (float)jarg2;
81126   {
81127     try {
81128       (arg1)->SetMaxFlickSpeed(arg2);
81129     } catch (std::out_of_range& e) {
81130       {
81131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81132       };
81133     } catch (std::exception& e) {
81134       {
81135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81136       };
81137     } catch (Dali::DaliException e) {
81138       {
81139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81140       };
81141     } catch (...) {
81142       {
81143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81144       };
81145     }
81146   }
81147
81148 }
81149
81150
81151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81152   void * jresult ;
81153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81154   Dali::Vector2 result;
81155
81156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81157   {
81158     try {
81159       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81160     } catch (std::out_of_range& e) {
81161       {
81162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81163       };
81164     } catch (std::exception& e) {
81165       {
81166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (Dali::DaliException e) {
81169       {
81170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81171       };
81172     } catch (...) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81175       };
81176     }
81177   }
81178
81179   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81180   return jresult;
81181 }
81182
81183
81184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81186   Dali::Vector2 arg2 ;
81187   Dali::Vector2 *argp2 ;
81188
81189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81190   argp2 = (Dali::Vector2 *)jarg2;
81191   if (!argp2) {
81192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81193     return ;
81194   }
81195   arg2 = *argp2;
81196   {
81197     try {
81198       (arg1)->SetWheelScrollDistanceStep(arg2);
81199     } catch (std::out_of_range& e) {
81200       {
81201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81202       };
81203     } catch (std::exception& e) {
81204       {
81205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81206       };
81207     } catch (Dali::DaliException e) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81210       };
81211     } catch (...) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81214       };
81215     }
81216   }
81217
81218 }
81219
81220
81221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81222   void * jresult ;
81223   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81224   Dali::Vector2 result;
81225
81226   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81227   {
81228     try {
81229       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81230     } catch (std::out_of_range& e) {
81231       {
81232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81233       };
81234     } catch (std::exception& e) {
81235       {
81236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81237       };
81238     } catch (Dali::DaliException e) {
81239       {
81240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81241       };
81242     } catch (...) {
81243       {
81244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81245       };
81246     }
81247   }
81248
81249   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81250   return jresult;
81251 }
81252
81253
81254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81255   unsigned int jresult ;
81256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81257   unsigned int result;
81258
81259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81260   {
81261     try {
81262       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81263     } catch (std::out_of_range& e) {
81264       {
81265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81266       };
81267     } catch (std::exception& e) {
81268       {
81269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (Dali::DaliException e) {
81272       {
81273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81274       };
81275     } catch (...) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81278       };
81279     }
81280   }
81281
81282   jresult = result;
81283   return jresult;
81284 }
81285
81286
81287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81288   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81289   Dali::Vector2 *arg2 = 0 ;
81290
81291   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81292   arg2 = (Dali::Vector2 *)jarg2;
81293   if (!arg2) {
81294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81295     return ;
81296   }
81297   {
81298     try {
81299       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81300     } catch (std::out_of_range& e) {
81301       {
81302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81303       };
81304     } catch (std::exception& e) {
81305       {
81306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81307       };
81308     } catch (Dali::DaliException e) {
81309       {
81310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81311       };
81312     } catch (...) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81315       };
81316     }
81317   }
81318
81319 }
81320
81321
81322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81324   Dali::Vector2 *arg2 = 0 ;
81325   float arg3 ;
81326
81327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81328   arg2 = (Dali::Vector2 *)jarg2;
81329   if (!arg2) {
81330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81331     return ;
81332   }
81333   arg3 = (float)jarg3;
81334   {
81335     try {
81336       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81352       };
81353     }
81354   }
81355
81356 }
81357
81358
81359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81361   Dali::Vector2 *arg2 = 0 ;
81362   float arg3 ;
81363   Dali::AlphaFunction arg4 ;
81364   Dali::AlphaFunction *argp4 ;
81365
81366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81367   arg2 = (Dali::Vector2 *)jarg2;
81368   if (!arg2) {
81369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81370     return ;
81371   }
81372   arg3 = (float)jarg3;
81373   argp4 = (Dali::AlphaFunction *)jarg4;
81374   if (!argp4) {
81375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81376     return ;
81377   }
81378   arg4 = *argp4;
81379   {
81380     try {
81381       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81382     } catch (std::out_of_range& e) {
81383       {
81384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81385       };
81386     } catch (std::exception& e) {
81387       {
81388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81389       };
81390     } catch (Dali::DaliException e) {
81391       {
81392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81393       };
81394     } catch (...) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81397       };
81398     }
81399   }
81400
81401 }
81402
81403
81404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81406   Dali::Vector2 *arg2 = 0 ;
81407   float arg3 ;
81408   Dali::Toolkit::DirectionBias arg4 ;
81409   Dali::Toolkit::DirectionBias arg5 ;
81410
81411   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81412   arg2 = (Dali::Vector2 *)jarg2;
81413   if (!arg2) {
81414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81415     return ;
81416   }
81417   arg3 = (float)jarg3;
81418   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81419   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81420   {
81421     try {
81422       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81423     } catch (std::out_of_range& e) {
81424       {
81425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81426       };
81427     } catch (std::exception& e) {
81428       {
81429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81430       };
81431     } catch (Dali::DaliException e) {
81432       {
81433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81434       };
81435     } catch (...) {
81436       {
81437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81438       };
81439     }
81440   }
81441
81442 }
81443
81444
81445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81447   Dali::Vector2 *arg2 = 0 ;
81448   float arg3 ;
81449   Dali::AlphaFunction arg4 ;
81450   Dali::Toolkit::DirectionBias arg5 ;
81451   Dali::Toolkit::DirectionBias arg6 ;
81452   Dali::AlphaFunction *argp4 ;
81453
81454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81455   arg2 = (Dali::Vector2 *)jarg2;
81456   if (!arg2) {
81457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81458     return ;
81459   }
81460   arg3 = (float)jarg3;
81461   argp4 = (Dali::AlphaFunction *)jarg4;
81462   if (!argp4) {
81463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81464     return ;
81465   }
81466   arg4 = *argp4;
81467   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81468   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81469   {
81470     try {
81471       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (Dali::DaliException e) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81487       };
81488     }
81489   }
81490
81491 }
81492
81493
81494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81496   unsigned int arg2 ;
81497
81498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81499   arg2 = (unsigned int)jarg2;
81500   {
81501     try {
81502       (arg1)->ScrollTo(arg2);
81503     } catch (std::out_of_range& e) {
81504       {
81505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81506       };
81507     } catch (std::exception& e) {
81508       {
81509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81510       };
81511     } catch (Dali::DaliException e) {
81512       {
81513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81514       };
81515     } catch (...) {
81516       {
81517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81518       };
81519     }
81520   }
81521
81522 }
81523
81524
81525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81527   unsigned int arg2 ;
81528   float arg3 ;
81529
81530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81531   arg2 = (unsigned int)jarg2;
81532   arg3 = (float)jarg3;
81533   {
81534     try {
81535       (arg1)->ScrollTo(arg2,arg3);
81536     } catch (std::out_of_range& e) {
81537       {
81538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81539       };
81540     } catch (std::exception& e) {
81541       {
81542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (Dali::DaliException e) {
81545       {
81546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81547       };
81548     } catch (...) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81551       };
81552     }
81553   }
81554
81555 }
81556
81557
81558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81559   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81560   unsigned int arg2 ;
81561   float arg3 ;
81562   Dali::Toolkit::DirectionBias arg4 ;
81563
81564   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81565   arg2 = (unsigned int)jarg2;
81566   arg3 = (float)jarg3;
81567   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81568   {
81569     try {
81570       (arg1)->ScrollTo(arg2,arg3,arg4);
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (Dali::DaliException e) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81582       };
81583     } catch (...) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81586       };
81587     }
81588   }
81589
81590 }
81591
81592
81593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81595   Dali::Actor *arg2 = 0 ;
81596
81597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81598   arg2 = (Dali::Actor *)jarg2;
81599   if (!arg2) {
81600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81601     return ;
81602   }
81603   {
81604     try {
81605       (arg1)->ScrollTo(*arg2);
81606     } catch (std::out_of_range& e) {
81607       {
81608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81609       };
81610     } catch (std::exception& e) {
81611       {
81612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (Dali::DaliException e) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81621       };
81622     }
81623   }
81624
81625 }
81626
81627
81628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81630   Dali::Actor *arg2 = 0 ;
81631   float arg3 ;
81632
81633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81634   arg2 = (Dali::Actor *)jarg2;
81635   if (!arg2) {
81636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81637     return ;
81638   }
81639   arg3 = (float)jarg3;
81640   {
81641     try {
81642       (arg1)->ScrollTo(*arg2,arg3);
81643     } catch (std::out_of_range& e) {
81644       {
81645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81646       };
81647     } catch (std::exception& e) {
81648       {
81649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81650       };
81651     } catch (Dali::DaliException e) {
81652       {
81653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81654       };
81655     } catch (...) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81658       };
81659     }
81660   }
81661
81662 }
81663
81664
81665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81666   unsigned int jresult ;
81667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81668   bool result;
81669
81670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81671   {
81672     try {
81673       result = (bool)(arg1)->ScrollToSnapPoint();
81674     } catch (std::out_of_range& e) {
81675       {
81676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81677       };
81678     } catch (std::exception& e) {
81679       {
81680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81681       };
81682     } catch (Dali::DaliException e) {
81683       {
81684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81685       };
81686     } catch (...) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81689       };
81690     }
81691   }
81692
81693   jresult = result;
81694   return jresult;
81695 }
81696
81697
81698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81700   Dali::Constraint arg2 ;
81701   Dali::Constraint *argp2 ;
81702
81703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81704   argp2 = (Dali::Constraint *)jarg2;
81705   if (!argp2) {
81706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81707     return ;
81708   }
81709   arg2 = *argp2;
81710   {
81711     try {
81712       (arg1)->ApplyConstraintToChildren(arg2);
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (Dali::DaliException e) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81724       };
81725     } catch (...) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81728       };
81729     }
81730   }
81731
81732 }
81733
81734
81735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737
81738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81739   {
81740     try {
81741       (arg1)->RemoveConstraintsFromChildren();
81742     } catch (std::out_of_range& e) {
81743       {
81744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81745       };
81746     } catch (std::exception& e) {
81747       {
81748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81749       };
81750     } catch (Dali::DaliException e) {
81751       {
81752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81753       };
81754     } catch (...) {
81755       {
81756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81757       };
81758     }
81759   }
81760
81761 }
81762
81763
81764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81766   Dali::Toolkit::ScrollViewEffect arg2 ;
81767   Dali::Toolkit::ScrollViewEffect *argp2 ;
81768
81769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81770   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81771   if (!argp2) {
81772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81773     return ;
81774   }
81775   arg2 = *argp2;
81776   {
81777     try {
81778       (arg1)->ApplyEffect(arg2);
81779     } catch (std::out_of_range& e) {
81780       {
81781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81782       };
81783     } catch (std::exception& e) {
81784       {
81785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81786       };
81787     } catch (Dali::DaliException e) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81790       };
81791     } catch (...) {
81792       {
81793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81794       };
81795     }
81796   }
81797
81798 }
81799
81800
81801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81802   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81803   Dali::Toolkit::ScrollViewEffect arg2 ;
81804   Dali::Toolkit::ScrollViewEffect *argp2 ;
81805
81806   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81807   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81808   if (!argp2) {
81809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81810     return ;
81811   }
81812   arg2 = *argp2;
81813   {
81814     try {
81815       (arg1)->RemoveEffect(arg2);
81816     } catch (std::out_of_range& e) {
81817       {
81818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81819       };
81820     } catch (std::exception& e) {
81821       {
81822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81823       };
81824     } catch (Dali::DaliException e) {
81825       {
81826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81827       };
81828     } catch (...) {
81829       {
81830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81831       };
81832     }
81833   }
81834
81835 }
81836
81837
81838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81840
81841   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81842   {
81843     try {
81844       (arg1)->RemoveAllEffects();
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (Dali::DaliException e) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81856       };
81857     } catch (...) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81860       };
81861     }
81862   }
81863
81864 }
81865
81866
81867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81868   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81869   Dali::Actor arg2 ;
81870   Dali::Actor *argp2 ;
81871
81872   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81873   argp2 = (Dali::Actor *)jarg2;
81874   if (!argp2) {
81875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81876     return ;
81877   }
81878   arg2 = *argp2;
81879   {
81880     try {
81881       (arg1)->BindActor(arg2);
81882     } catch (std::out_of_range& e) {
81883       {
81884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81885       };
81886     } catch (std::exception& e) {
81887       {
81888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81889       };
81890     } catch (Dali::DaliException e) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81893       };
81894     } catch (...) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81897       };
81898     }
81899   }
81900
81901 }
81902
81903
81904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81906   Dali::Actor arg2 ;
81907   Dali::Actor *argp2 ;
81908
81909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81910   argp2 = (Dali::Actor *)jarg2;
81911   if (!argp2) {
81912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81913     return ;
81914   }
81915   arg2 = *argp2;
81916   {
81917     try {
81918       (arg1)->UnbindActor(arg2);
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (Dali::DaliException e) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81930       };
81931     } catch (...) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81934       };
81935     }
81936   }
81937
81938 }
81939
81940
81941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81943   Dali::Radian arg2 ;
81944   Dali::Radian arg3 ;
81945   Dali::Radian *argp2 ;
81946   Dali::Radian *argp3 ;
81947
81948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81949   argp2 = (Dali::Radian *)jarg2;
81950   if (!argp2) {
81951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81952     return ;
81953   }
81954   arg2 = *argp2;
81955   argp3 = (Dali::Radian *)jarg3;
81956   if (!argp3) {
81957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81958     return ;
81959   }
81960   arg3 = *argp3;
81961   {
81962     try {
81963       (arg1)->SetScrollingDirection(arg2,arg3);
81964     } catch (std::out_of_range& e) {
81965       {
81966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81967       };
81968     } catch (std::exception& e) {
81969       {
81970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81971       };
81972     } catch (Dali::DaliException e) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81975       };
81976     } catch (...) {
81977       {
81978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81979       };
81980     }
81981   }
81982
81983 }
81984
81985
81986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81988   Dali::Radian arg2 ;
81989   Dali::Radian *argp2 ;
81990
81991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81992   argp2 = (Dali::Radian *)jarg2;
81993   if (!argp2) {
81994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81995     return ;
81996   }
81997   arg2 = *argp2;
81998   {
81999     try {
82000       (arg1)->SetScrollingDirection(arg2);
82001     } catch (std::out_of_range& e) {
82002       {
82003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82004       };
82005     } catch (std::exception& e) {
82006       {
82007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82008       };
82009     } catch (Dali::DaliException e) {
82010       {
82011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82012       };
82013     } catch (...) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82016       };
82017     }
82018   }
82019
82020 }
82021
82022
82023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82025   Dali::Radian arg2 ;
82026   Dali::Radian *argp2 ;
82027
82028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82029   argp2 = (Dali::Radian *)jarg2;
82030   if (!argp2) {
82031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82032     return ;
82033   }
82034   arg2 = *argp2;
82035   {
82036     try {
82037       (arg1)->RemoveScrollingDirection(arg2);
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82053       };
82054     }
82055   }
82056
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82061   void * jresult ;
82062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82063   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82064
82065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82066   {
82067     try {
82068       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (Dali::DaliException e) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82080       };
82081     } catch (...) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82084       };
82085     }
82086   }
82087
82088   jresult = (void *)result;
82089   return jresult;
82090 }
82091
82092
82093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82094   int jresult ;
82095   int result;
82096
82097   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82098   jresult = (int)result;
82099   return jresult;
82100 }
82101
82102
82103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82104   int jresult ;
82105   int result;
82106
82107   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82108   jresult = (int)result;
82109   return jresult;
82110 }
82111
82112
82113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82114   int jresult ;
82115   int result;
82116
82117   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82118   jresult = (int)result;
82119   return jresult;
82120 }
82121
82122
82123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82124   int jresult ;
82125   int result;
82126
82127   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82128   jresult = (int)result;
82129   return jresult;
82130 }
82131
82132
82133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82134   int jresult ;
82135   int result;
82136
82137   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82138   jresult = (int)result;
82139   return jresult;
82140 }
82141
82142
82143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82144   void * jresult ;
82145   Dali::Toolkit::TableView::Property *result = 0 ;
82146
82147   {
82148     try {
82149       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82165       };
82166     }
82167   }
82168
82169   jresult = (void *)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82175   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82176
82177   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82178   {
82179     try {
82180       delete arg1;
82181     } catch (std::out_of_range& e) {
82182       {
82183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82184       };
82185     } catch (std::exception& e) {
82186       {
82187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82188       };
82189     } catch (Dali::DaliException e) {
82190       {
82191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82196       };
82197     }
82198   }
82199
82200 }
82201
82202
82203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82204   int jresult ;
82205   int result;
82206
82207   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82208   jresult = (int)result;
82209   return jresult;
82210 }
82211
82212
82213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82214   int jresult ;
82215   int result;
82216
82217   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82218   jresult = (int)result;
82219   return jresult;
82220 }
82221
82222
82223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82224   int jresult ;
82225   int result;
82226
82227   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82228   jresult = (int)result;
82229   return jresult;
82230 }
82231
82232
82233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82234   int jresult ;
82235   int result;
82236
82237   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82238   jresult = (int)result;
82239   return jresult;
82240 }
82241
82242
82243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82244   int jresult ;
82245   int result;
82246
82247   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82248   jresult = (int)result;
82249   return jresult;
82250 }
82251
82252
82253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82254   void * jresult ;
82255   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82256
82257   {
82258     try {
82259       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82260     } catch (std::out_of_range& e) {
82261       {
82262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82263       };
82264     } catch (std::exception& e) {
82265       {
82266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82267       };
82268     } catch (Dali::DaliException e) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82271       };
82272     } catch (...) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82275       };
82276     }
82277   }
82278
82279   jresult = (void *)result;
82280   return jresult;
82281 }
82282
82283
82284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82285   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82286
82287   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82288   {
82289     try {
82290       delete arg1;
82291     } catch (std::out_of_range& e) {
82292       {
82293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82294       };
82295     } catch (std::exception& e) {
82296       {
82297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (Dali::DaliException e) {
82300       {
82301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82302       };
82303     } catch (...) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82306       };
82307     }
82308   }
82309
82310 }
82311
82312
82313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82314   void * jresult ;
82315   unsigned int arg1 ;
82316   unsigned int arg2 ;
82317   unsigned int arg3 ;
82318   unsigned int arg4 ;
82319   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82320
82321   arg1 = (unsigned int)jarg1;
82322   arg2 = (unsigned int)jarg2;
82323   arg3 = (unsigned int)jarg3;
82324   arg4 = (unsigned int)jarg4;
82325   {
82326     try {
82327       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82328     } catch (std::out_of_range& e) {
82329       {
82330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (std::exception& e) {
82333       {
82334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (Dali::DaliException e) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82339       };
82340     } catch (...) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82343       };
82344     }
82345   }
82346
82347   jresult = (void *)result;
82348   return jresult;
82349 }
82350
82351
82352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82353   void * jresult ;
82354   unsigned int arg1 ;
82355   unsigned int arg2 ;
82356   unsigned int arg3 ;
82357   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82358
82359   arg1 = (unsigned int)jarg1;
82360   arg2 = (unsigned int)jarg2;
82361   arg3 = (unsigned int)jarg3;
82362   {
82363     try {
82364       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82365     } catch (std::out_of_range& e) {
82366       {
82367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82368       };
82369     } catch (std::exception& e) {
82370       {
82371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82372       };
82373     } catch (Dali::DaliException e) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82376       };
82377     } catch (...) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82380       };
82381     }
82382   }
82383
82384   jresult = (void *)result;
82385   return jresult;
82386 }
82387
82388
82389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82390   void * jresult ;
82391   unsigned int arg1 ;
82392   unsigned int arg2 ;
82393   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82394
82395   arg1 = (unsigned int)jarg1;
82396   arg2 = (unsigned int)jarg2;
82397   {
82398     try {
82399       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
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_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82425   void * jresult ;
82426   unsigned int arg1 ;
82427   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82428
82429   arg1 = (unsigned int)jarg1;
82430   {
82431     try {
82432       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
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 void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82458   void * jresult ;
82459   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82460
82461   {
82462     try {
82463       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (Dali::DaliException e) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82475       };
82476     } catch (...) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82479       };
82480     }
82481   }
82482
82483   jresult = (void *)result;
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82489   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82490   unsigned int arg2 ;
82491
82492   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82493   arg2 = (unsigned int)jarg2;
82494   if (arg1) (arg1)->rowIndex = arg2;
82495 }
82496
82497
82498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82499   unsigned int jresult ;
82500   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82501   unsigned int result;
82502
82503   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82504   result = (unsigned int) ((arg1)->rowIndex);
82505   jresult = result;
82506   return jresult;
82507 }
82508
82509
82510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82511   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82512   unsigned int arg2 ;
82513
82514   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82515   arg2 = (unsigned int)jarg2;
82516   if (arg1) (arg1)->columnIndex = arg2;
82517 }
82518
82519
82520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82521   unsigned int jresult ;
82522   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82523   unsigned int result;
82524
82525   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82526   result = (unsigned int) ((arg1)->columnIndex);
82527   jresult = result;
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82533   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82534   unsigned int arg2 ;
82535
82536   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82537   arg2 = (unsigned int)jarg2;
82538   if (arg1) (arg1)->rowSpan = arg2;
82539 }
82540
82541
82542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82543   unsigned int jresult ;
82544   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82545   unsigned int result;
82546
82547   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82548   result = (unsigned int) ((arg1)->rowSpan);
82549   jresult = result;
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82555   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82556   unsigned int arg2 ;
82557
82558   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82559   arg2 = (unsigned int)jarg2;
82560   if (arg1) (arg1)->columnSpan = arg2;
82561 }
82562
82563
82564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82565   unsigned int jresult ;
82566   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82567   unsigned int result;
82568
82569   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82570   result = (unsigned int) ((arg1)->columnSpan);
82571   jresult = result;
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82577   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82578
82579   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82580   {
82581     try {
82582       delete arg1;
82583     } catch (std::out_of_range& e) {
82584       {
82585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82586       };
82587     } catch (std::exception& e) {
82588       {
82589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82590       };
82591     } catch (Dali::DaliException e) {
82592       {
82593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82594       };
82595     } catch (...) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82598       };
82599     }
82600   }
82601
82602 }
82603
82604
82605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82606   void * jresult ;
82607   Dali::Toolkit::TableView *result = 0 ;
82608
82609   {
82610     try {
82611       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82612     } catch (std::out_of_range& e) {
82613       {
82614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82615       };
82616     } catch (std::exception& e) {
82617       {
82618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82619       };
82620     } catch (Dali::DaliException e) {
82621       {
82622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82623       };
82624     } catch (...) {
82625       {
82626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82627       };
82628     }
82629   }
82630
82631   jresult = (void *)result;
82632   return jresult;
82633 }
82634
82635
82636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82637   void * jresult ;
82638   Dali::Toolkit::TableView *arg1 = 0 ;
82639   Dali::Toolkit::TableView *result = 0 ;
82640
82641   arg1 = (Dali::Toolkit::TableView *)jarg1;
82642   if (!arg1) {
82643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82644     return 0;
82645   }
82646   {
82647     try {
82648       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (Dali::DaliException e) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82664       };
82665     }
82666   }
82667
82668   jresult = (void *)result;
82669   return jresult;
82670 }
82671
82672
82673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82674   void * jresult ;
82675   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82676   Dali::Toolkit::TableView *arg2 = 0 ;
82677   Dali::Toolkit::TableView *result = 0 ;
82678
82679   arg1 = (Dali::Toolkit::TableView *)jarg1;
82680   arg2 = (Dali::Toolkit::TableView *)jarg2;
82681   if (!arg2) {
82682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82683     return 0;
82684   }
82685   {
82686     try {
82687       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82688     } catch (std::out_of_range& e) {
82689       {
82690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82691       };
82692     } catch (std::exception& e) {
82693       {
82694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82695       };
82696     } catch (Dali::DaliException e) {
82697       {
82698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82699       };
82700     } catch (...) {
82701       {
82702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82703       };
82704     }
82705   }
82706
82707   jresult = (void *)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82713   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82714
82715   arg1 = (Dali::Toolkit::TableView *)jarg1;
82716   {
82717     try {
82718       delete arg1;
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82726       };
82727     } catch (Dali::DaliException e) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82734       };
82735     }
82736   }
82737
82738 }
82739
82740
82741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82742   void * jresult ;
82743   unsigned int arg1 ;
82744   unsigned int arg2 ;
82745   Dali::Toolkit::TableView result;
82746
82747   arg1 = (unsigned int)jarg1;
82748   arg2 = (unsigned int)jarg2;
82749   {
82750     try {
82751       result = Dali::Toolkit::TableView::New(arg1,arg2);
82752     } catch (std::out_of_range& e) {
82753       {
82754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82755       };
82756     } catch (std::exception& e) {
82757       {
82758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82759       };
82760     } catch (Dali::DaliException e) {
82761       {
82762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82763       };
82764     } catch (...) {
82765       {
82766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82767       };
82768     }
82769   }
82770
82771   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82772   return jresult;
82773 }
82774
82775
82776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82777   void * jresult ;
82778   Dali::BaseHandle arg1 ;
82779   Dali::BaseHandle *argp1 ;
82780   Dali::Toolkit::TableView result;
82781
82782   argp1 = (Dali::BaseHandle *)jarg1;
82783   if (!argp1) {
82784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82785     return 0;
82786   }
82787   arg1 = *argp1;
82788   {
82789     try {
82790       result = Dali::Toolkit::TableView::DownCast(arg1);
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82806       };
82807     }
82808   }
82809
82810   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82811   return jresult;
82812 }
82813
82814
82815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82816   unsigned int jresult ;
82817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82818   Dali::Actor arg2 ;
82819   Dali::Toolkit::TableView::CellPosition arg3 ;
82820   Dali::Actor *argp2 ;
82821   Dali::Toolkit::TableView::CellPosition *argp3 ;
82822   bool result;
82823
82824   arg1 = (Dali::Toolkit::TableView *)jarg1;
82825   argp2 = (Dali::Actor *)jarg2;
82826   if (!argp2) {
82827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82828     return 0;
82829   }
82830   arg2 = *argp2;
82831   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82832   if (!argp3) {
82833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82834     return 0;
82835   }
82836   arg3 = *argp3;
82837   {
82838     try {
82839       result = (bool)(arg1)->AddChild(arg2,arg3);
82840     } catch (std::out_of_range& e) {
82841       {
82842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82843       };
82844     } catch (std::exception& e) {
82845       {
82846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82847       };
82848     } catch (Dali::DaliException e) {
82849       {
82850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82851       };
82852     } catch (...) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82855       };
82856     }
82857   }
82858
82859   jresult = result;
82860   return jresult;
82861 }
82862
82863
82864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82865   void * jresult ;
82866   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82867   Dali::Toolkit::TableView::CellPosition arg2 ;
82868   Dali::Toolkit::TableView::CellPosition *argp2 ;
82869   Dali::Actor result;
82870
82871   arg1 = (Dali::Toolkit::TableView *)jarg1;
82872   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82873   if (!argp2) {
82874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82875     return 0;
82876   }
82877   arg2 = *argp2;
82878   {
82879     try {
82880       result = (arg1)->GetChildAt(arg2);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (Dali::DaliException e) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82892       };
82893     } catch (...) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82896       };
82897     }
82898   }
82899
82900   jresult = new Dali::Actor((const Dali::Actor &)result);
82901   return jresult;
82902 }
82903
82904
82905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82906   void * jresult ;
82907   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82908   Dali::Toolkit::TableView::CellPosition arg2 ;
82909   Dali::Toolkit::TableView::CellPosition *argp2 ;
82910   Dali::Actor result;
82911
82912   arg1 = (Dali::Toolkit::TableView *)jarg1;
82913   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82914   if (!argp2) {
82915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82916     return 0;
82917   }
82918   arg2 = *argp2;
82919   {
82920     try {
82921       result = (arg1)->RemoveChildAt(arg2);
82922     } catch (std::out_of_range& e) {
82923       {
82924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82925       };
82926     } catch (std::exception& e) {
82927       {
82928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82929       };
82930     } catch (Dali::DaliException e) {
82931       {
82932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82933       };
82934     } catch (...) {
82935       {
82936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82937       };
82938     }
82939   }
82940
82941   jresult = new Dali::Actor((const Dali::Actor &)result);
82942   return jresult;
82943 }
82944
82945
82946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82947   unsigned int jresult ;
82948   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82949   Dali::Actor arg2 ;
82950   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82951   Dali::Actor *argp2 ;
82952   bool result;
82953
82954   arg1 = (Dali::Toolkit::TableView *)jarg1;
82955   argp2 = (Dali::Actor *)jarg2;
82956   if (!argp2) {
82957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82958     return 0;
82959   }
82960   arg2 = *argp2;
82961   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82962   if (!arg3) {
82963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82964     return 0;
82965   }
82966   {
82967     try {
82968       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82969     } catch (std::out_of_range& e) {
82970       {
82971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82972       };
82973     } catch (std::exception& e) {
82974       {
82975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (Dali::DaliException e) {
82978       {
82979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82980       };
82981     } catch (...) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82984       };
82985     }
82986   }
82987
82988   jresult = result;
82989   return jresult;
82990 }
82991
82992
82993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82994   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82995   unsigned int arg2 ;
82996
82997   arg1 = (Dali::Toolkit::TableView *)jarg1;
82998   arg2 = (unsigned int)jarg2;
82999   {
83000     try {
83001       (arg1)->InsertRow(arg2);
83002     } catch (std::out_of_range& e) {
83003       {
83004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (std::exception& e) {
83007       {
83008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (Dali::DaliException e) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83017       };
83018     }
83019   }
83020
83021 }
83022
83023
83024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83025   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83026   unsigned int arg2 ;
83027
83028   arg1 = (Dali::Toolkit::TableView *)jarg1;
83029   arg2 = (unsigned int)jarg2;
83030   {
83031     try {
83032       (arg1)->DeleteRow(arg2);
83033     } catch (std::out_of_range& e) {
83034       {
83035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83036       };
83037     } catch (std::exception& e) {
83038       {
83039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (Dali::DaliException e) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83044       };
83045     } catch (...) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83048       };
83049     }
83050   }
83051
83052 }
83053
83054
83055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83056   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83057   unsigned int arg2 ;
83058   std::vector< Dali::Actor > *arg3 = 0 ;
83059
83060   arg1 = (Dali::Toolkit::TableView *)jarg1;
83061   arg2 = (unsigned int)jarg2;
83062   arg3 = (std::vector< Dali::Actor > *)jarg3;
83063   if (!arg3) {
83064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83065     return ;
83066   }
83067   {
83068     try {
83069       (arg1)->DeleteRow(arg2,*arg3);
83070     } catch (std::out_of_range& e) {
83071       {
83072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83073       };
83074     } catch (std::exception& e) {
83075       {
83076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83077       };
83078     } catch (Dali::DaliException e) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83081       };
83082     } catch (...) {
83083       {
83084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83085       };
83086     }
83087   }
83088
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83093   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83094   unsigned int arg2 ;
83095
83096   arg1 = (Dali::Toolkit::TableView *)jarg1;
83097   arg2 = (unsigned int)jarg2;
83098   {
83099     try {
83100       (arg1)->InsertColumn(arg2);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (Dali::DaliException e) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83116       };
83117     }
83118   }
83119
83120 }
83121
83122
83123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83124   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83125   unsigned int arg2 ;
83126
83127   arg1 = (Dali::Toolkit::TableView *)jarg1;
83128   arg2 = (unsigned int)jarg2;
83129   {
83130     try {
83131       (arg1)->DeleteColumn(arg2);
83132     } catch (std::out_of_range& e) {
83133       {
83134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83135       };
83136     } catch (std::exception& e) {
83137       {
83138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83139       };
83140     } catch (Dali::DaliException e) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83143       };
83144     } catch (...) {
83145       {
83146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83147       };
83148     }
83149   }
83150
83151 }
83152
83153
83154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83155   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83156   unsigned int arg2 ;
83157   std::vector< Dali::Actor > *arg3 = 0 ;
83158
83159   arg1 = (Dali::Toolkit::TableView *)jarg1;
83160   arg2 = (unsigned int)jarg2;
83161   arg3 = (std::vector< Dali::Actor > *)jarg3;
83162   if (!arg3) {
83163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83164     return ;
83165   }
83166   {
83167     try {
83168       (arg1)->DeleteColumn(arg2,*arg3);
83169     } catch (std::out_of_range& e) {
83170       {
83171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83172       };
83173     } catch (std::exception& e) {
83174       {
83175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83176       };
83177     } catch (Dali::DaliException e) {
83178       {
83179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83180       };
83181     } catch (...) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83184       };
83185     }
83186   }
83187
83188 }
83189
83190
83191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83193   unsigned int arg2 ;
83194   unsigned int arg3 ;
83195
83196   arg1 = (Dali::Toolkit::TableView *)jarg1;
83197   arg2 = (unsigned int)jarg2;
83198   arg3 = (unsigned int)jarg3;
83199   {
83200     try {
83201       (arg1)->Resize(arg2,arg3);
83202     } catch (std::out_of_range& e) {
83203       {
83204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83205       };
83206     } catch (std::exception& e) {
83207       {
83208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83209       };
83210     } catch (Dali::DaliException e) {
83211       {
83212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83213       };
83214     } catch (...) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83217       };
83218     }
83219   }
83220
83221 }
83222
83223
83224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83226   unsigned int arg2 ;
83227   unsigned int arg3 ;
83228   std::vector< Dali::Actor > *arg4 = 0 ;
83229
83230   arg1 = (Dali::Toolkit::TableView *)jarg1;
83231   arg2 = (unsigned int)jarg2;
83232   arg3 = (unsigned int)jarg3;
83233   arg4 = (std::vector< Dali::Actor > *)jarg4;
83234   if (!arg4) {
83235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83236     return ;
83237   }
83238   {
83239     try {
83240       (arg1)->Resize(arg2,arg3,*arg4);
83241     } catch (std::out_of_range& e) {
83242       {
83243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83244       };
83245     } catch (std::exception& e) {
83246       {
83247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83248       };
83249     } catch (Dali::DaliException e) {
83250       {
83251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83256       };
83257     }
83258   }
83259
83260 }
83261
83262
83263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83264   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83265   Dali::Size arg2 ;
83266   Dali::Size *argp2 ;
83267
83268   arg1 = (Dali::Toolkit::TableView *)jarg1;
83269   argp2 = (Dali::Size *)jarg2;
83270   if (!argp2) {
83271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83272     return ;
83273   }
83274   arg2 = *argp2;
83275   {
83276     try {
83277       (arg1)->SetCellPadding(arg2);
83278     } catch (std::out_of_range& e) {
83279       {
83280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83281       };
83282     } catch (std::exception& e) {
83283       {
83284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83285       };
83286     } catch (Dali::DaliException e) {
83287       {
83288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83289       };
83290     } catch (...) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83293       };
83294     }
83295   }
83296
83297 }
83298
83299
83300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83301   void * jresult ;
83302   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83303   Dali::Size result;
83304
83305   arg1 = (Dali::Toolkit::TableView *)jarg1;
83306   {
83307     try {
83308       result = (arg1)->GetCellPadding();
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (Dali::DaliException e) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83320       };
83321     } catch (...) {
83322       {
83323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83324       };
83325     }
83326   }
83327
83328   jresult = new Dali::Size((const Dali::Size &)result);
83329   return jresult;
83330 }
83331
83332
83333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83335   unsigned int arg2 ;
83336
83337   arg1 = (Dali::Toolkit::TableView *)jarg1;
83338   arg2 = (unsigned int)jarg2;
83339   {
83340     try {
83341       (arg1)->SetFitHeight(arg2);
83342     } catch (std::out_of_range& e) {
83343       {
83344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83345       };
83346     } catch (std::exception& e) {
83347       {
83348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (Dali::DaliException e) {
83351       {
83352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83353       };
83354     } catch (...) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83357       };
83358     }
83359   }
83360
83361 }
83362
83363
83364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83365   unsigned int jresult ;
83366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83367   unsigned int arg2 ;
83368   bool result;
83369
83370   arg1 = (Dali::Toolkit::TableView *)jarg1;
83371   arg2 = (unsigned int)jarg2;
83372   {
83373     try {
83374       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83375     } catch (std::out_of_range& e) {
83376       {
83377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83378       };
83379     } catch (std::exception& e) {
83380       {
83381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (Dali::DaliException e) {
83384       {
83385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83386       };
83387     } catch (...) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83390       };
83391     }
83392   }
83393
83394   jresult = result;
83395   return jresult;
83396 }
83397
83398
83399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83400   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83401   unsigned int arg2 ;
83402
83403   arg1 = (Dali::Toolkit::TableView *)jarg1;
83404   arg2 = (unsigned int)jarg2;
83405   {
83406     try {
83407       (arg1)->SetFitWidth(arg2);
83408     } catch (std::out_of_range& e) {
83409       {
83410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83411       };
83412     } catch (std::exception& e) {
83413       {
83414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83415       };
83416     } catch (Dali::DaliException e) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83419       };
83420     } catch (...) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83423       };
83424     }
83425   }
83426
83427 }
83428
83429
83430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83431   unsigned int jresult ;
83432   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83433   unsigned int arg2 ;
83434   bool result;
83435
83436   arg1 = (Dali::Toolkit::TableView *)jarg1;
83437   arg2 = (unsigned int)jarg2;
83438   {
83439     try {
83440       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (Dali::DaliException e) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83452       };
83453     } catch (...) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83456       };
83457     }
83458   }
83459
83460   jresult = result;
83461   return jresult;
83462 }
83463
83464
83465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83466   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83467   unsigned int arg2 ;
83468   float arg3 ;
83469
83470   arg1 = (Dali::Toolkit::TableView *)jarg1;
83471   arg2 = (unsigned int)jarg2;
83472   arg3 = (float)jarg3;
83473   {
83474     try {
83475       (arg1)->SetFixedHeight(arg2,arg3);
83476     } catch (std::out_of_range& e) {
83477       {
83478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83479       };
83480     } catch (std::exception& e) {
83481       {
83482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83483       };
83484     } catch (Dali::DaliException e) {
83485       {
83486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83487       };
83488     } catch (...) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83491       };
83492     }
83493   }
83494
83495 }
83496
83497
83498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83499   float jresult ;
83500   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83501   unsigned int arg2 ;
83502   float result;
83503
83504   arg1 = (Dali::Toolkit::TableView *)jarg1;
83505   arg2 = (unsigned int)jarg2;
83506   {
83507     try {
83508       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83509     } catch (std::out_of_range& e) {
83510       {
83511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83512       };
83513     } catch (std::exception& e) {
83514       {
83515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (Dali::DaliException e) {
83518       {
83519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83520       };
83521     } catch (...) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83524       };
83525     }
83526   }
83527
83528   jresult = result;
83529   return jresult;
83530 }
83531
83532
83533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83534   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83535   unsigned int arg2 ;
83536   float arg3 ;
83537
83538   arg1 = (Dali::Toolkit::TableView *)jarg1;
83539   arg2 = (unsigned int)jarg2;
83540   arg3 = (float)jarg3;
83541   {
83542     try {
83543       (arg1)->SetRelativeHeight(arg2,arg3);
83544     } catch (std::out_of_range& e) {
83545       {
83546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83547       };
83548     } catch (std::exception& e) {
83549       {
83550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83551       };
83552     } catch (Dali::DaliException e) {
83553       {
83554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83555       };
83556     } catch (...) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83559       };
83560     }
83561   }
83562
83563 }
83564
83565
83566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83567   float jresult ;
83568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83569   unsigned int arg2 ;
83570   float result;
83571
83572   arg1 = (Dali::Toolkit::TableView *)jarg1;
83573   arg2 = (unsigned int)jarg2;
83574   {
83575     try {
83576       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83577     } catch (std::out_of_range& e) {
83578       {
83579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83580       };
83581     } catch (std::exception& e) {
83582       {
83583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (Dali::DaliException e) {
83586       {
83587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83588       };
83589     } catch (...) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83592       };
83593     }
83594   }
83595
83596   jresult = result;
83597   return jresult;
83598 }
83599
83600
83601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83602   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83603   unsigned int arg2 ;
83604   float arg3 ;
83605
83606   arg1 = (Dali::Toolkit::TableView *)jarg1;
83607   arg2 = (unsigned int)jarg2;
83608   arg3 = (float)jarg3;
83609   {
83610     try {
83611       (arg1)->SetFixedWidth(arg2,arg3);
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83619       };
83620     } catch (Dali::DaliException e) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83627       };
83628     }
83629   }
83630
83631 }
83632
83633
83634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83635   float jresult ;
83636   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83637   unsigned int arg2 ;
83638   float result;
83639
83640   arg1 = (Dali::Toolkit::TableView *)jarg1;
83641   arg2 = (unsigned int)jarg2;
83642   {
83643     try {
83644       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83645     } catch (std::out_of_range& e) {
83646       {
83647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83648       };
83649     } catch (std::exception& e) {
83650       {
83651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83652       };
83653     } catch (Dali::DaliException e) {
83654       {
83655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83656       };
83657     } catch (...) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83660       };
83661     }
83662   }
83663
83664   jresult = result;
83665   return jresult;
83666 }
83667
83668
83669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83670   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83671   unsigned int arg2 ;
83672   float arg3 ;
83673
83674   arg1 = (Dali::Toolkit::TableView *)jarg1;
83675   arg2 = (unsigned int)jarg2;
83676   arg3 = (float)jarg3;
83677   {
83678     try {
83679       (arg1)->SetRelativeWidth(arg2,arg3);
83680     } catch (std::out_of_range& e) {
83681       {
83682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83683       };
83684     } catch (std::exception& e) {
83685       {
83686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83687       };
83688     } catch (Dali::DaliException e) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83691       };
83692     } catch (...) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83695       };
83696     }
83697   }
83698
83699 }
83700
83701
83702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83703   float jresult ;
83704   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83705   unsigned int arg2 ;
83706   float result;
83707
83708   arg1 = (Dali::Toolkit::TableView *)jarg1;
83709   arg2 = (unsigned int)jarg2;
83710   {
83711     try {
83712       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (Dali::DaliException e) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731
83732   jresult = result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83738   unsigned int jresult ;
83739   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83740   unsigned int result;
83741
83742   arg1 = (Dali::Toolkit::TableView *)jarg1;
83743   {
83744     try {
83745       result = (unsigned int)(arg1)->GetRows();
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83761       };
83762     }
83763   }
83764
83765   jresult = result;
83766   return jresult;
83767 }
83768
83769
83770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83771   unsigned int jresult ;
83772   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83773   unsigned int result;
83774
83775   arg1 = (Dali::Toolkit::TableView *)jarg1;
83776   {
83777     try {
83778       result = (unsigned int)(arg1)->GetColumns();
83779     } catch (std::out_of_range& e) {
83780       {
83781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (std::exception& e) {
83784       {
83785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (Dali::DaliException e) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797
83798   jresult = result;
83799   return jresult;
83800 }
83801
83802
83803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83804   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83805   Dali::Toolkit::TableView::CellPosition arg2 ;
83806   Dali::HorizontalAlignment::Type arg3 ;
83807   Dali::VerticalAlignment::Type arg4 ;
83808   Dali::Toolkit::TableView::CellPosition *argp2 ;
83809
83810   arg1 = (Dali::Toolkit::TableView *)jarg1;
83811   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83812   if (!argp2) {
83813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83814     return ;
83815   }
83816   arg2 = *argp2;
83817   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83818   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83819   {
83820     try {
83821       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83822     } catch (std::out_of_range& e) {
83823       {
83824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83825       };
83826     } catch (std::exception& e) {
83827       {
83828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83829       };
83830     } catch (Dali::DaliException e) {
83831       {
83832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83833       };
83834     } catch (...) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83837       };
83838     }
83839   }
83840
83841 }
83842
83843
83844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83845   unsigned int jresult ;
83846   unsigned int result;
83847
83848   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83849   jresult = result;
83850   return jresult;
83851 }
83852
83853
83854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83855   int jresult ;
83856   int result;
83857
83858   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83859   jresult = (int)result;
83860   return jresult;
83861 }
83862
83863
83864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83865   int jresult ;
83866   int result;
83867
83868   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83869   jresult = (int)result;
83870   return jresult;
83871 }
83872
83873
83874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83875   int jresult ;
83876   int result;
83877
83878   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83879   jresult = (int)result;
83880   return jresult;
83881 }
83882
83883
83884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83885   int jresult ;
83886   int result;
83887
83888   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83889   jresult = (int)result;
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83895   int jresult ;
83896   int result;
83897
83898   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83899   jresult = (int)result;
83900   return jresult;
83901 }
83902
83903
83904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83905   int jresult ;
83906   int result;
83907
83908   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83909   jresult = (int)result;
83910   return jresult;
83911 }
83912
83913
83914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83915   int jresult ;
83916   int result;
83917
83918   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83919   jresult = (int)result;
83920   return jresult;
83921 }
83922
83923
83924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83925   int jresult ;
83926   int result;
83927
83928   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83929   jresult = (int)result;
83930   return jresult;
83931 }
83932
83933
83934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83935   int jresult ;
83936   int result;
83937
83938   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83939   jresult = (int)result;
83940   return jresult;
83941 }
83942
83943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83944   int jresult ;
83945   int result;
83946
83947   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83948   jresult = (int)result;
83949   return jresult;
83950 }
83951
83952
83953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83954   int jresult ;
83955   int result;
83956
83957   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83958   jresult = (int)result;
83959   return jresult;
83960 }
83961
83962
83963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83964   int jresult ;
83965   int result;
83966
83967   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83968   jresult = (int)result;
83969   return jresult;
83970 }
83971
83972
83973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83974   int jresult ;
83975   int result;
83976
83977   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83978   jresult = (int)result;
83979   return jresult;
83980 }
83981
83982
83983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83984   int jresult ;
83985   int result;
83986
83987   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83988   jresult = (int)result;
83989   return jresult;
83990 }
83991
83992
83993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83994   int jresult ;
83995   int result;
83996
83997   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83998   jresult = (int)result;
83999   return jresult;
84000 }
84001
84002
84003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84004   int jresult ;
84005   int result;
84006
84007   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84008   jresult = (int)result;
84009   return jresult;
84010 }
84011
84012
84013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84014   int jresult ;
84015   int result;
84016
84017   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84018   jresult = (int)result;
84019   return jresult;
84020 }
84021
84022
84023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84024   int jresult ;
84025   int result;
84026
84027   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84028   jresult = (int)result;
84029   return jresult;
84030 }
84031
84032
84033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84034   int jresult ;
84035   int result;
84036
84037   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84038   jresult = (int)result;
84039   return jresult;
84040 }
84041
84042
84043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84044   int jresult ;
84045   int result;
84046
84047   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84048   jresult = (int)result;
84049   return jresult;
84050 }
84051
84052
84053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84054   int jresult ;
84055   int result;
84056
84057   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84058   jresult = (int)result;
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84064   int jresult ;
84065   int result;
84066
84067   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84068   jresult = (int)result;
84069   return jresult;
84070 }
84071
84072
84073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84074   int jresult ;
84075   int result;
84076
84077   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84078   jresult = (int)result;
84079   return jresult;
84080 }
84081
84082
84083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84084   int jresult ;
84085   int result;
84086
84087   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84088   jresult = (int)result;
84089   return jresult;
84090 }
84091
84092
84093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84094   void * jresult ;
84095   Dali::Toolkit::TextLabel::Property *result = 0 ;
84096
84097   {
84098     try {
84099       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84100     } catch (std::out_of_range& e) {
84101       {
84102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84103       };
84104     } catch (std::exception& e) {
84105       {
84106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (Dali::DaliException e) {
84109       {
84110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84111       };
84112     } catch (...) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84115       };
84116     }
84117   }
84118
84119   jresult = (void *)result;
84120   return jresult;
84121 }
84122
84123
84124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84125   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84126
84127   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84128   {
84129     try {
84130       delete arg1;
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (Dali::DaliException e) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84142       };
84143     } catch (...) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84146       };
84147     }
84148   }
84149
84150 }
84151
84152
84153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84154   void * jresult ;
84155   Dali::Toolkit::TextLabel result;
84156
84157   {
84158     try {
84159       result = Dali::Toolkit::TextLabel::New();
84160
84161       // default behaviour of NUI TextLabel
84162       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84163     } catch (std::out_of_range& e) {
84164       {
84165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (std::exception& e) {
84168       {
84169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84170       };
84171     } catch (Dali::DaliException e) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84174       };
84175     } catch (...) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84178       };
84179     }
84180   }
84181
84182   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84183   return jresult;
84184 }
84185
84186
84187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84188   void * jresult ;
84189   std::string *arg1 = 0 ;
84190   Dali::Toolkit::TextLabel result;
84191
84192   if (!jarg1) {
84193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84194     return 0;
84195   }
84196   std::string arg1_str(jarg1);
84197   arg1 = &arg1_str;
84198   {
84199     try {
84200       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84201
84202       // default behaviour of NUI TextLabel
84203       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84204     } catch (std::out_of_range& e) {
84205       {
84206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84207       };
84208     } catch (std::exception& e) {
84209       {
84210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84211       };
84212     } catch (Dali::DaliException e) {
84213       {
84214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84215       };
84216     } catch (...) {
84217       {
84218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84219       };
84220     }
84221   }
84222
84223   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84224
84225   //argout typemap for const std::string&
84226
84227   return jresult;
84228 }
84229
84230
84231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84232   void * jresult ;
84233   Dali::Toolkit::TextLabel *result = 0 ;
84234
84235   {
84236     try {
84237       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84238     } catch (std::out_of_range& e) {
84239       {
84240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84241       };
84242     } catch (std::exception& e) {
84243       {
84244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84245       };
84246     } catch (Dali::DaliException e) {
84247       {
84248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84249       };
84250     } catch (...) {
84251       {
84252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84253       };
84254     }
84255   }
84256
84257   jresult = (void *)result;
84258   return jresult;
84259 }
84260
84261
84262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84263   void * jresult ;
84264   Dali::Toolkit::TextLabel *arg1 = 0 ;
84265   Dali::Toolkit::TextLabel *result = 0 ;
84266
84267   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84268   if (!arg1) {
84269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84270     return 0;
84271   }
84272   {
84273     try {
84274       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84275     } catch (std::out_of_range& e) {
84276       {
84277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84278       };
84279     } catch (std::exception& e) {
84280       {
84281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (Dali::DaliException e) {
84284       {
84285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84286       };
84287     } catch (...) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84290       };
84291     }
84292   }
84293
84294   jresult = (void *)result;
84295   return jresult;
84296 }
84297
84298
84299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84300   void * jresult ;
84301   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84302   Dali::Toolkit::TextLabel *arg2 = 0 ;
84303   Dali::Toolkit::TextLabel *result = 0 ;
84304
84305   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84306   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84307   if (!arg2) {
84308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84309     return 0;
84310   }
84311   {
84312     try {
84313       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84314     } catch (std::out_of_range& e) {
84315       {
84316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84317       };
84318     } catch (std::exception& e) {
84319       {
84320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (Dali::DaliException e) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84329       };
84330     }
84331   }
84332
84333   jresult = (void *)result;
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84339   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84340
84341   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84342   {
84343     try {
84344       delete arg1;
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (Dali::DaliException e) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84356       };
84357     } catch (...) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84360       };
84361     }
84362   }
84363
84364 }
84365
84366
84367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84368   void * jresult ;
84369   Dali::BaseHandle arg1 ;
84370   Dali::BaseHandle *argp1 ;
84371   Dali::Toolkit::TextLabel result;
84372
84373   argp1 = (Dali::BaseHandle *)jarg1;
84374   if (!argp1) {
84375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84376     return 0;
84377   }
84378   arg1 = *argp1;
84379   {
84380     try {
84381       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84382     } catch (std::out_of_range& e) {
84383       {
84384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (std::exception& e) {
84387       {
84388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (Dali::DaliException e) {
84391       {
84392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84393       };
84394     } catch (...) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84397       };
84398     }
84399   }
84400
84401   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84402   return jresult;
84403 }
84404
84405
84406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84407   void * jresult ;
84408   Dali::Toolkit::AccessibilityManager *result = 0 ;
84409
84410   {
84411     try {
84412       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84413     } catch (std::out_of_range& e) {
84414       {
84415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84416       };
84417     } catch (std::exception& e) {
84418       {
84419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84420       };
84421     } catch (Dali::DaliException e) {
84422       {
84423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84424       };
84425     } catch (...) {
84426       {
84427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84428       };
84429     }
84430   }
84431
84432   jresult = (void *)result;
84433   return jresult;
84434 }
84435
84436
84437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84438   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84439
84440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84441   {
84442     try {
84443       delete arg1;
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84451       };
84452     } catch (Dali::DaliException e) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84455       };
84456     } catch (...) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84459       };
84460     }
84461   }
84462
84463 }
84464
84465
84466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84467   void * jresult ;
84468   Dali::Toolkit::AccessibilityManager result;
84469
84470   {
84471     try {
84472       result = Dali::Toolkit::AccessibilityManager::Get();
84473     } catch (std::out_of_range& e) {
84474       {
84475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (std::exception& e) {
84478       {
84479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (Dali::DaliException e) {
84482       {
84483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84484       };
84485     } catch (...) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84488       };
84489     }
84490   }
84491
84492   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84493   return jresult;
84494 }
84495
84496
84497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84499   Dali::Actor arg2 ;
84500   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84501   std::string *arg4 = 0 ;
84502   Dali::Actor *argp2 ;
84503
84504   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84505   argp2 = (Dali::Actor *)jarg2;
84506   if (!argp2) {
84507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84508     return ;
84509   }
84510   arg2 = *argp2;
84511   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84512   if (!jarg4) {
84513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84514     return ;
84515   }
84516   std::string arg4_str(jarg4);
84517   arg4 = &arg4_str;
84518   {
84519     try {
84520       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84521     } catch (std::out_of_range& e) {
84522       {
84523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84524       };
84525     } catch (std::exception& e) {
84526       {
84527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84528       };
84529     } catch (Dali::DaliException e) {
84530       {
84531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84532       };
84533     } catch (...) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84536       };
84537     }
84538   }
84539
84540
84541   //argout typemap for const std::string&
84542
84543 }
84544
84545
84546 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84547   char * jresult ;
84548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84549   Dali::Actor arg2 ;
84550   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84551   Dali::Actor *argp2 ;
84552   std::string result;
84553
84554   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84555   argp2 = (Dali::Actor *)jarg2;
84556   if (!argp2) {
84557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84558     return 0;
84559   }
84560   arg2 = *argp2;
84561   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84562   {
84563     try {
84564       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84565     } catch (std::out_of_range& e) {
84566       {
84567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84568       };
84569     } catch (std::exception& e) {
84570       {
84571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (Dali::DaliException e) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84580       };
84581     }
84582   }
84583
84584   jresult = SWIG_csharp_string_callback((&result)->c_str());
84585   return jresult;
84586 }
84587
84588
84589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84591   Dali::Actor arg2 ;
84592   unsigned int arg3 ;
84593   Dali::Actor *argp2 ;
84594
84595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84596   argp2 = (Dali::Actor *)jarg2;
84597   if (!argp2) {
84598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84599     return ;
84600   }
84601   arg2 = *argp2;
84602   arg3 = (unsigned int)jarg3;
84603   {
84604     try {
84605       (arg1)->SetFocusOrder(arg2,arg3);
84606     } catch (std::out_of_range& e) {
84607       {
84608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84609       };
84610     } catch (std::exception& e) {
84611       {
84612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (Dali::DaliException e) {
84615       {
84616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84617       };
84618     } catch (...) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84621       };
84622     }
84623   }
84624
84625 }
84626
84627
84628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84629   unsigned int jresult ;
84630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84631   Dali::Actor arg2 ;
84632   Dali::Actor *argp2 ;
84633   unsigned int result;
84634
84635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84636   argp2 = (Dali::Actor *)jarg2;
84637   if (!argp2) {
84638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84639     return 0;
84640   }
84641   arg2 = *argp2;
84642   {
84643     try {
84644       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (Dali::DaliException e) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84660       };
84661     }
84662   }
84663
84664   jresult = result;
84665   return jresult;
84666 }
84667
84668
84669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84670   unsigned int jresult ;
84671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84672   unsigned int result;
84673
84674   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84675   {
84676     try {
84677       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84678     } catch (std::out_of_range& e) {
84679       {
84680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (std::exception& e) {
84683       {
84684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (Dali::DaliException e) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84689       };
84690     } catch (...) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84693       };
84694     }
84695   }
84696
84697   jresult = result;
84698   return jresult;
84699 }
84700
84701
84702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84703   void * jresult ;
84704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84705   unsigned int arg2 ;
84706   Dali::Actor result;
84707
84708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84709   arg2 = (unsigned int)jarg2;
84710   {
84711     try {
84712       result = (arg1)->GetActorByFocusOrder(arg2);
84713     } catch (std::out_of_range& e) {
84714       {
84715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (std::exception& e) {
84718       {
84719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (Dali::DaliException e) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84728       };
84729     }
84730   }
84731
84732   jresult = new Dali::Actor((const Dali::Actor &)result);
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84738   unsigned int jresult ;
84739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84740   Dali::Actor arg2 ;
84741   Dali::Actor *argp2 ;
84742   bool result;
84743
84744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84745   argp2 = (Dali::Actor *)jarg2;
84746   if (!argp2) {
84747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84748     return 0;
84749   }
84750   arg2 = *argp2;
84751   {
84752     try {
84753       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84754     } catch (std::out_of_range& e) {
84755       {
84756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84757       };
84758     } catch (std::exception& e) {
84759       {
84760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84761       };
84762     } catch (Dali::DaliException e) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84765       };
84766     } catch (...) {
84767       {
84768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84769       };
84770     }
84771   }
84772
84773   jresult = result;
84774   return jresult;
84775 }
84776
84777
84778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84779   void * jresult ;
84780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84781   Dali::Actor result;
84782
84783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84784   {
84785     try {
84786       result = (arg1)->GetCurrentFocusActor();
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (Dali::DaliException e) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84798       };
84799     } catch (...) {
84800       {
84801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84802       };
84803     }
84804   }
84805
84806   jresult = new Dali::Actor((const Dali::Actor &)result);
84807   return jresult;
84808 }
84809
84810
84811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84812   void * jresult ;
84813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84814   Dali::Actor result;
84815
84816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84817   {
84818     try {
84819       result = (arg1)->GetCurrentFocusGroup();
84820     } catch (std::out_of_range& e) {
84821       {
84822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (std::exception& e) {
84825       {
84826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84827       };
84828     } catch (Dali::DaliException e) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84831       };
84832     } catch (...) {
84833       {
84834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84835       };
84836     }
84837   }
84838
84839   jresult = new Dali::Actor((const Dali::Actor &)result);
84840   return jresult;
84841 }
84842
84843
84844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84845   unsigned int jresult ;
84846   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84847   unsigned int result;
84848
84849   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84850   {
84851     try {
84852       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84853     } catch (std::out_of_range& e) {
84854       {
84855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84856       };
84857     } catch (std::exception& e) {
84858       {
84859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (Dali::DaliException e) {
84862       {
84863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871
84872   jresult = result;
84873   return jresult;
84874 }
84875
84876
84877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84878   unsigned int jresult ;
84879   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84880   bool result;
84881
84882   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84883   {
84884     try {
84885       result = (bool)(arg1)->MoveFocusForward();
84886     } catch (std::out_of_range& e) {
84887       {
84888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84889       };
84890     } catch (std::exception& e) {
84891       {
84892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84893       };
84894     } catch (Dali::DaliException e) {
84895       {
84896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84897       };
84898     } catch (...) {
84899       {
84900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84901       };
84902     }
84903   }
84904
84905   jresult = result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84911   unsigned int jresult ;
84912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84913   bool result;
84914
84915   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84916   {
84917     try {
84918       result = (bool)(arg1)->MoveFocusBackward();
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84926       };
84927     } catch (Dali::DaliException e) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84930       };
84931     } catch (...) {
84932       {
84933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84934       };
84935     }
84936   }
84937
84938   jresult = result;
84939   return jresult;
84940 }
84941
84942
84943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84944   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84945
84946   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84947   {
84948     try {
84949       (arg1)->ClearFocus();
84950     } catch (std::out_of_range& e) {
84951       {
84952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84953       };
84954     } catch (std::exception& e) {
84955       {
84956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84957       };
84958     } catch (Dali::DaliException e) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84961       };
84962     } catch (...) {
84963       {
84964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84965       };
84966     }
84967   }
84968
84969 }
84970
84971
84972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84974
84975   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84976   {
84977     try {
84978       (arg1)->Reset();
84979     } catch (std::out_of_range& e) {
84980       {
84981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84982       };
84983     } catch (std::exception& e) {
84984       {
84985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84986       };
84987     } catch (Dali::DaliException e) {
84988       {
84989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84990       };
84991     } catch (...) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84994       };
84995     }
84996   }
84997
84998 }
84999
85000
85001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85003   Dali::Actor arg2 ;
85004   bool arg3 ;
85005   Dali::Actor *argp2 ;
85006
85007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85008   argp2 = (Dali::Actor *)jarg2;
85009   if (!argp2) {
85010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85011     return ;
85012   }
85013   arg2 = *argp2;
85014   arg3 = jarg3 ? true : false;
85015   {
85016     try {
85017       (arg1)->SetFocusGroup(arg2,arg3);
85018     } catch (std::out_of_range& e) {
85019       {
85020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85021       };
85022     } catch (std::exception& e) {
85023       {
85024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85025       };
85026     } catch (Dali::DaliException e) {
85027       {
85028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85029       };
85030     } catch (...) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85033       };
85034     }
85035   }
85036
85037 }
85038
85039
85040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85041   unsigned int jresult ;
85042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85043   Dali::Actor arg2 ;
85044   Dali::Actor *argp2 ;
85045   bool result;
85046
85047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85048   argp2 = (Dali::Actor *)jarg2;
85049   if (!argp2) {
85050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85051     return 0;
85052   }
85053   arg2 = *argp2;
85054   {
85055     try {
85056       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (Dali::DaliException e) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85072       };
85073     }
85074   }
85075
85076   jresult = result;
85077   return jresult;
85078 }
85079
85080
85081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85083   bool arg2 ;
85084
85085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85086   arg2 = jarg2 ? true : false;
85087   {
85088     try {
85089       (arg1)->SetGroupMode(arg2);
85090     } catch (std::out_of_range& e) {
85091       {
85092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85093       };
85094     } catch (std::exception& e) {
85095       {
85096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85097       };
85098     } catch (Dali::DaliException e) {
85099       {
85100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85101       };
85102     } catch (...) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85105       };
85106     }
85107   }
85108
85109 }
85110
85111
85112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85113   unsigned int jresult ;
85114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85115   bool result;
85116
85117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85118   {
85119     try {
85120       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85121     } catch (std::out_of_range& e) {
85122       {
85123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85124       };
85125     } catch (std::exception& e) {
85126       {
85127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85128       };
85129     } catch (Dali::DaliException e) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85132       };
85133     } catch (...) {
85134       {
85135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85136       };
85137     }
85138   }
85139
85140   jresult = result;
85141   return jresult;
85142 }
85143
85144
85145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85147   bool arg2 ;
85148
85149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85150   arg2 = jarg2 ? true : false;
85151   {
85152     try {
85153       (arg1)->SetWrapMode(arg2);
85154     } catch (std::out_of_range& e) {
85155       {
85156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85157       };
85158     } catch (std::exception& e) {
85159       {
85160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85161       };
85162     } catch (Dali::DaliException e) {
85163       {
85164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85165       };
85166     } catch (...) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85169       };
85170     }
85171   }
85172
85173 }
85174
85175
85176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85177   unsigned int jresult ;
85178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85179   bool result;
85180
85181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85182   {
85183     try {
85184       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85185     } catch (std::out_of_range& e) {
85186       {
85187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (std::exception& e) {
85190       {
85191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85192       };
85193     } catch (Dali::DaliException e) {
85194       {
85195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85196       };
85197     } catch (...) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85200       };
85201     }
85202   }
85203
85204   jresult = result;
85205   return jresult;
85206 }
85207
85208
85209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85211   Dali::Actor arg2 ;
85212   Dali::Actor *argp2 ;
85213
85214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85215   argp2 = (Dali::Actor *)jarg2;
85216   if (!argp2) {
85217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85218     return ;
85219   }
85220   arg2 = *argp2;
85221   {
85222     try {
85223       (arg1)->SetFocusIndicatorActor(arg2);
85224     } catch (std::out_of_range& e) {
85225       {
85226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85227       };
85228     } catch (std::exception& e) {
85229       {
85230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85231       };
85232     } catch (Dali::DaliException e) {
85233       {
85234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85235       };
85236     } catch (...) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85239       };
85240     }
85241   }
85242
85243 }
85244
85245
85246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85247   void * jresult ;
85248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85249   Dali::Actor result;
85250
85251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85252   {
85253     try {
85254       result = (arg1)->GetFocusIndicatorActor();
85255     } catch (std::out_of_range& e) {
85256       {
85257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85258       };
85259     } catch (std::exception& e) {
85260       {
85261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (Dali::DaliException e) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85266       };
85267     } catch (...) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85270       };
85271     }
85272   }
85273
85274   jresult = new Dali::Actor((const Dali::Actor &)result);
85275   return jresult;
85276 }
85277
85278
85279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85280   void * jresult ;
85281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85282   Dali::Actor arg2 ;
85283   Dali::Actor *argp2 ;
85284   Dali::Actor result;
85285
85286   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85287   argp2 = (Dali::Actor *)jarg2;
85288   if (!argp2) {
85289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85290     return 0;
85291   }
85292   arg2 = *argp2;
85293   {
85294     try {
85295       result = (arg1)->GetFocusGroup(arg2);
85296     } catch (std::out_of_range& e) {
85297       {
85298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85299       };
85300     } catch (std::exception& e) {
85301       {
85302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85303       };
85304     } catch (Dali::DaliException e) {
85305       {
85306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85307       };
85308     } catch (...) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85311       };
85312     }
85313   }
85314
85315   jresult = new Dali::Actor((const Dali::Actor &)result);
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85321   void * jresult ;
85322   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85323   Dali::Vector2 result;
85324
85325   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85326   {
85327     try {
85328       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85329     } catch (std::out_of_range& e) {
85330       {
85331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (std::exception& e) {
85334       {
85335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85336       };
85337     } catch (Dali::DaliException e) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85340       };
85341     } catch (...) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85344       };
85345     }
85346   }
85347
85348   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85349   return jresult;
85350 }
85351
85352
85353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85354   void * jresult ;
85355   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85356   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85357
85358   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85359   {
85360     try {
85361       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85362     } catch (std::out_of_range& e) {
85363       {
85364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85365       };
85366     } catch (std::exception& e) {
85367       {
85368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (Dali::DaliException e) {
85371       {
85372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85373       };
85374     } catch (...) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85377       };
85378     }
85379   }
85380
85381   jresult = (void *)result;
85382   return jresult;
85383 }
85384
85385
85386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85387   void * jresult ;
85388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85389   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85390
85391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85392   {
85393     try {
85394       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85395     } catch (std::out_of_range& e) {
85396       {
85397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85398       };
85399     } catch (std::exception& e) {
85400       {
85401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (Dali::DaliException e) {
85404       {
85405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85410       };
85411     }
85412   }
85413
85414   jresult = (void *)result;
85415   return jresult;
85416 }
85417
85418
85419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85420   void * jresult ;
85421   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85422   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85423
85424   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85425   {
85426     try {
85427       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85428     } catch (std::out_of_range& e) {
85429       {
85430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (std::exception& e) {
85433       {
85434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (Dali::DaliException e) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85439       };
85440     } catch (...) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85443       };
85444     }
85445   }
85446
85447   jresult = (void *)result;
85448   return jresult;
85449 }
85450
85451
85452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85453   void * jresult ;
85454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85455   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85456
85457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85458   {
85459     try {
85460       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85461     } catch (std::out_of_range& e) {
85462       {
85463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85464       };
85465     } catch (std::exception& e) {
85466       {
85467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85468       };
85469     } catch (Dali::DaliException e) {
85470       {
85471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85472       };
85473     } catch (...) {
85474       {
85475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85476       };
85477     }
85478   }
85479
85480   jresult = (void *)result;
85481   return jresult;
85482 }
85483
85484
85485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85486   void * jresult ;
85487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85488   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85489
85490   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85491   {
85492     try {
85493       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85494     } catch (std::out_of_range& e) {
85495       {
85496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85497       };
85498     } catch (std::exception& e) {
85499       {
85500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85501       };
85502     } catch (Dali::DaliException e) {
85503       {
85504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85505       };
85506     } catch (...) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85509       };
85510     }
85511   }
85512
85513   jresult = (void *)result;
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85519   void * jresult ;
85520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85521   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85522
85523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85524   {
85525     try {
85526       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85527     } catch (std::out_of_range& e) {
85528       {
85529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (std::exception& e) {
85532       {
85533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (Dali::DaliException e) {
85536       {
85537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85538       };
85539     } catch (...) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85542       };
85543     }
85544   }
85545
85546   jresult = (void *)result;
85547   return jresult;
85548 }
85549
85550
85551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85552   void * jresult ;
85553   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85554   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85555
85556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85557   {
85558     try {
85559       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85560     } catch (std::out_of_range& e) {
85561       {
85562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (std::exception& e) {
85565       {
85566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (Dali::DaliException e) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85571       };
85572     } catch (...) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85575       };
85576     }
85577   }
85578
85579   jresult = (void *)result;
85580   return jresult;
85581 }
85582
85583
85584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85585   void * jresult ;
85586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85587   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85588
85589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85590   {
85591     try {
85592       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85593     } catch (std::out_of_range& e) {
85594       {
85595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85596       };
85597     } catch (std::exception& e) {
85598       {
85599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85600       };
85601     } catch (Dali::DaliException e) {
85602       {
85603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85604       };
85605     } catch (...) {
85606       {
85607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85608       };
85609     }
85610   }
85611
85612   jresult = (void *)result;
85613   return jresult;
85614 }
85615
85616
85617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85618   void * jresult ;
85619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85620   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85621
85622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85623   {
85624     try {
85625       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85626     } catch (std::out_of_range& e) {
85627       {
85628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85629       };
85630     } catch (std::exception& e) {
85631       {
85632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85633       };
85634     } catch (Dali::DaliException e) {
85635       {
85636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85637       };
85638     } catch (...) {
85639       {
85640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85641       };
85642     }
85643   }
85644
85645   jresult = (void *)result;
85646   return jresult;
85647 }
85648
85649
85650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85651   void * jresult ;
85652   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85653   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85654
85655   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85656   {
85657     try {
85658       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85659     } catch (std::out_of_range& e) {
85660       {
85661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (std::exception& e) {
85664       {
85665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (Dali::DaliException e) {
85668       {
85669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85670       };
85671     } catch (...) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85674       };
85675     }
85676   }
85677
85678   jresult = (void *)result;
85679   return jresult;
85680 }
85681
85682
85683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85684   void * jresult ;
85685   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85686   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85687
85688   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85689   {
85690     try {
85691       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85692     } catch (std::out_of_range& e) {
85693       {
85694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85695       };
85696     } catch (std::exception& e) {
85697       {
85698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (Dali::DaliException e) {
85701       {
85702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85703       };
85704     } catch (...) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85707       };
85708     }
85709   }
85710
85711   jresult = (void *)result;
85712   return jresult;
85713 }
85714
85715
85716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85717   void * jresult ;
85718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85720
85721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85722   {
85723     try {
85724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85732       };
85733     } catch (Dali::DaliException e) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85736       };
85737     } catch (...) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85740       };
85741     }
85742   }
85743
85744   jresult = (void *)result;
85745   return jresult;
85746 }
85747
85748
85749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85750   void * jresult ;
85751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85753
85754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85755   {
85756     try {
85757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85773       };
85774     }
85775   }
85776
85777   jresult = (void *)result;
85778   return jresult;
85779 }
85780
85781
85782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85783   void * jresult ;
85784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85785   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85786
85787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85788   {
85789     try {
85790       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
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_AccessibilityManager_ActionBackSignal(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85818   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85821   {
85822     try {
85823       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85824     } catch (std::out_of_range& e) {
85825       {
85826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (std::exception& e) {
85829       {
85830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (Dali::DaliException e) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85839       };
85840     }
85841   }
85842
85843   jresult = (void *)result;
85844   return jresult;
85845 }
85846
85847
85848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85849   void * jresult ;
85850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85852
85853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85854   {
85855     try {
85856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85857     } catch (std::out_of_range& e) {
85858       {
85859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (std::exception& e) {
85862       {
85863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (Dali::DaliException e) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875
85876   jresult = (void *)result;
85877   return jresult;
85878 }
85879
85880
85881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85882   void * jresult ;
85883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85884   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85885
85886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85887   {
85888     try {
85889       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85905       };
85906     }
85907   }
85908
85909   jresult = (void *)result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85915   void * jresult ;
85916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85917   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85918
85919   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85920   {
85921     try {
85922       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (Dali::DaliException e) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85934       };
85935     } catch (...) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85938       };
85939     }
85940   }
85941
85942   jresult = (void *)result;
85943   return jresult;
85944 }
85945
85946
85947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85948   void * jresult ;
85949   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85950   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85951
85952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85953   {
85954     try {
85955       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (Dali::DaliException e) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974
85975   jresult = (void *)result;
85976   return jresult;
85977 }
85978
85979
85980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85981   void * jresult ;
85982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85983   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85984
85985   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85986   {
85987     try {
85988       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85989     } catch (std::out_of_range& e) {
85990       {
85991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85992       };
85993     } catch (std::exception& e) {
85994       {
85995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (Dali::DaliException e) {
85998       {
85999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86000       };
86001     } catch (...) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86004       };
86005     }
86006   }
86007
86008   jresult = (void *)result;
86009   return jresult;
86010 }
86011
86012
86013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86014   void * jresult ;
86015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86016   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86017
86018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86019   {
86020     try {
86021       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (Dali::DaliException e) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86033       };
86034     } catch (...) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86037       };
86038     }
86039   }
86040
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86047   void * jresult ;
86048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86050
86051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86052   {
86053     try {
86054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86055     } catch (std::out_of_range& e) {
86056       {
86057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86058       };
86059     } catch (std::exception& e) {
86060       {
86061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (Dali::DaliException e) {
86064       {
86065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073
86074   jresult = (void *)result;
86075   return jresult;
86076 }
86077
86078
86079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86080   void * jresult ;
86081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86082   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86083
86084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86085   {
86086     try {
86087       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86103       };
86104     }
86105   }
86106
86107   jresult = (void *)result;
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86113   void * jresult ;
86114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86116
86117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86118   {
86119     try {
86120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86121     } catch (std::out_of_range& e) {
86122       {
86123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (std::exception& e) {
86126       {
86127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (Dali::DaliException e) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86132       };
86133     } catch (...) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86136       };
86137     }
86138   }
86139
86140   jresult = (void *)result;
86141   return jresult;
86142 }
86143
86144
86145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86146   void * jresult ;
86147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86148   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86149
86150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86151   {
86152     try {
86153       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (Dali::DaliException e) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86165       };
86166     } catch (...) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86169       };
86170     }
86171   }
86172
86173   jresult = (void *)result;
86174   return jresult;
86175 }
86176
86177
86178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86179   void * jresult ;
86180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86182
86183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86184   {
86185     try {
86186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86187     } catch (std::out_of_range& e) {
86188       {
86189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86190       };
86191     } catch (std::exception& e) {
86192       {
86193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (Dali::DaliException e) {
86196       {
86197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86202       };
86203     }
86204   }
86205
86206   jresult = (void *)result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86212   void * jresult ;
86213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86215
86216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86217   {
86218     try {
86219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86220     } catch (std::out_of_range& e) {
86221       {
86222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86223       };
86224     } catch (std::exception& e) {
86225       {
86226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (Dali::DaliException e) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86231       };
86232     } catch (...) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86235       };
86236     }
86237   }
86238
86239   jresult = (void *)result;
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86245   void * jresult ;
86246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86248
86249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86250   {
86251     try {
86252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86253     } catch (std::out_of_range& e) {
86254       {
86255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86256       };
86257     } catch (std::exception& e) {
86258       {
86259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86260       };
86261     } catch (Dali::DaliException e) {
86262       {
86263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86264       };
86265     } catch (...) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86268       };
86269     }
86270   }
86271
86272   jresult = (void *)result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86278   void * jresult ;
86279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86280   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86281
86282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86283   {
86284     try {
86285       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86286     } catch (std::out_of_range& e) {
86287       {
86288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86289       };
86290     } catch (std::exception& e) {
86291       {
86292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (Dali::DaliException e) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86297       };
86298     } catch (...) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86301       };
86302     }
86303   }
86304
86305   jresult = (void *)result;
86306   return jresult;
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86311   void * jresult ;
86312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86313   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86314
86315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86316   {
86317     try {
86318       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (Dali::DaliException e) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86330       };
86331     } catch (...) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86334       };
86335     }
86336   }
86337
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86344   void * jresult ;
86345   Dali::Toolkit::StyleManager *result = 0 ;
86346
86347   {
86348     try {
86349       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (Dali::DaliException e) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86361       };
86362     } catch (...) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86365       };
86366     }
86367   }
86368
86369   jresult = (void *)result;
86370   return jresult;
86371 }
86372
86373
86374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86375   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86376
86377   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86378   {
86379     try {
86380       delete arg1;
86381     } catch (std::out_of_range& e) {
86382       {
86383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86384       };
86385     } catch (std::exception& e) {
86386       {
86387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (Dali::DaliException e) {
86390       {
86391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86392       };
86393     } catch (...) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86396       };
86397     }
86398   }
86399
86400 }
86401
86402
86403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86404   void * jresult ;
86405   Dali::Toolkit::StyleManager result;
86406
86407   {
86408     try {
86409       result = Dali::Toolkit::StyleManager::Get();
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 = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86430   return jresult;
86431 }
86432
86433
86434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86435   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86436   std::string *arg2 = 0 ;
86437
86438   arg1 = (Dali::Toolkit::StyleManager *)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)->ApplyTheme((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 void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86474   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86475
86476   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86477   {
86478     try {
86479       (arg1)->ApplyDefaultTheme();
86480     } catch (std::out_of_range& e) {
86481       {
86482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86483       };
86484     } catch (std::exception& e) {
86485       {
86486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86487       };
86488     } catch (Dali::DaliException e) {
86489       {
86490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86491       };
86492     } catch (...) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86495       };
86496     }
86497   }
86498
86499 }
86500
86501
86502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86503   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86504   std::string *arg2 = 0 ;
86505   Dali::Property::Value *arg3 = 0 ;
86506
86507   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86508   if (!jarg2) {
86509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86510     return ;
86511   }
86512   std::string arg2_str(jarg2);
86513   arg2 = &arg2_str;
86514   arg3 = (Dali::Property::Value *)jarg3;
86515   if (!arg3) {
86516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86517     return ;
86518   }
86519   {
86520     try {
86521       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86522     } catch (std::out_of_range& e) {
86523       {
86524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86525       };
86526     } catch (std::exception& e) {
86527       {
86528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86529       };
86530     } catch (Dali::DaliException e) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86533       };
86534     } catch (...) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86537       };
86538     }
86539   }
86540
86541
86542   //argout typemap for const std::string&
86543
86544 }
86545
86546
86547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86548   unsigned int jresult ;
86549   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86550   std::string *arg2 = 0 ;
86551   Dali::Property::Value *arg3 = 0 ;
86552   bool result;
86553
86554   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86555   if (!jarg2) {
86556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86557     return 0;
86558   }
86559   std::string arg2_str(jarg2);
86560   arg2 = &arg2_str;
86561   arg3 = (Dali::Property::Value *)jarg3;
86562   if (!arg3) {
86563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86564     return 0;
86565   }
86566   {
86567     try {
86568       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86569     } catch (std::out_of_range& e) {
86570       {
86571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86572       };
86573     } catch (std::exception& e) {
86574       {
86575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (Dali::DaliException e) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86580       };
86581     } catch (...) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86584       };
86585     }
86586   }
86587
86588   jresult = result;
86589
86590   //argout typemap for const std::string&
86591
86592   return jresult;
86593 }
86594
86595
86596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86597   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86598   Dali::Toolkit::Control arg2 ;
86599   std::string *arg3 = 0 ;
86600   std::string *arg4 = 0 ;
86601   Dali::Toolkit::Control *argp2 ;
86602
86603   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86604   argp2 = (Dali::Toolkit::Control *)jarg2;
86605   if (!argp2) {
86606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86607     return ;
86608   }
86609   arg2 = *argp2;
86610   if (!jarg3) {
86611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86612     return ;
86613   }
86614   std::string arg3_str(jarg3);
86615   arg3 = &arg3_str;
86616   if (!jarg4) {
86617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86618     return ;
86619   }
86620   std::string arg4_str(jarg4);
86621   arg4 = &arg4_str;
86622   {
86623     try {
86624       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86625     } catch (std::out_of_range& e) {
86626       {
86627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86628       };
86629     } catch (std::exception& e) {
86630       {
86631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86632       };
86633     } catch (Dali::DaliException e) {
86634       {
86635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86636       };
86637     } catch (...) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86640       };
86641     }
86642   }
86643
86644
86645   //argout typemap for const std::string&
86646
86647
86648   //argout typemap for const std::string&
86649
86650 }
86651
86652
86653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86654   void * jresult ;
86655   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86656   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86659   {
86660     try {
86661       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86662     } catch (std::out_of_range& e) {
86663       {
86664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (std::exception& e) {
86667       {
86668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (Dali::DaliException e) {
86671       {
86672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86677       };
86678     }
86679   }
86680
86681   jresult = (void *)result;
86682   return jresult;
86683 }
86684
86685
86686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86687   int jresult ;
86688   int result;
86689
86690   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86691   jresult = (int)result;
86692   return jresult;
86693 }
86694
86695
86696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86697   int jresult ;
86698   int result;
86699
86700   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86701   jresult = (int)result;
86702   return jresult;
86703 }
86704
86705
86706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86707   int jresult ;
86708   int result;
86709
86710   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86711   jresult = (int)result;
86712   return jresult;
86713 }
86714
86715
86716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86717   int jresult ;
86718   int result;
86719
86720   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86721   jresult = (int)result;
86722   return jresult;
86723 }
86724
86725
86726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86727   int jresult ;
86728   int result;
86729
86730   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86731   jresult = (int)result;
86732   return jresult;
86733 }
86734
86735
86736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86737   int jresult ;
86738   int result;
86739
86740   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86741   jresult = (int)result;
86742   return jresult;
86743 }
86744
86745
86746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86747   int jresult ;
86748   int result;
86749
86750   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86751   jresult = (int)result;
86752   return jresult;
86753 }
86754
86755
86756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86757   int jresult ;
86758   int result;
86759
86760   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86761   jresult = (int)result;
86762   return jresult;
86763 }
86764
86765
86766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86767   int jresult ;
86768   int result;
86769
86770   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86771   jresult = (int)result;
86772   return jresult;
86773 }
86774
86775
86776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86777   int jresult ;
86778   int result;
86779
86780   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86781   jresult = (int)result;
86782   return jresult;
86783 }
86784
86785
86786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86787   int jresult ;
86788   int result;
86789
86790   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86791   jresult = (int)result;
86792   return jresult;
86793 }
86794
86795
86796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86797   int jresult ;
86798   int result;
86799
86800   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86801   jresult = (int)result;
86802   return jresult;
86803 }
86804
86805
86806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86807   int jresult ;
86808   int result;
86809
86810   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86811   jresult = (int)result;
86812   return jresult;
86813 }
86814
86815
86816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86817   int jresult ;
86818   int result;
86819
86820   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86821   jresult = (int)result;
86822   return jresult;
86823 }
86824
86825
86826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86827   int jresult ;
86828   int result;
86829
86830   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86831   jresult = (int)result;
86832   return jresult;
86833 }
86834
86835
86836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86837   void * jresult ;
86838   Dali::Toolkit::Slider::Property *result = 0 ;
86839
86840   {
86841     try {
86842       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86843     } catch (std::out_of_range& e) {
86844       {
86845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86846       };
86847     } catch (std::exception& e) {
86848       {
86849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (Dali::DaliException e) {
86852       {
86853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86854       };
86855     } catch (...) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86858       };
86859     }
86860   }
86861
86862   jresult = (void *)result;
86863   return jresult;
86864 }
86865
86866
86867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86868   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86869
86870   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86871   {
86872     try {
86873       delete arg1;
86874     } catch (std::out_of_range& e) {
86875       {
86876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86877       };
86878     } catch (std::exception& e) {
86879       {
86880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86881       };
86882     } catch (Dali::DaliException e) {
86883       {
86884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86885       };
86886     } catch (...) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86889       };
86890     }
86891   }
86892
86893 }
86894
86895
86896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86897   void * jresult ;
86898   Dali::Toolkit::Slider result;
86899
86900   {
86901     try {
86902       result = Dali::Toolkit::Slider::New();
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (Dali::DaliException e) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86914       };
86915     } catch (...) {
86916       {
86917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86918       };
86919     }
86920   }
86921
86922   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86923   return jresult;
86924 }
86925
86926
86927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86928   void * jresult ;
86929   Dali::Toolkit::Slider *result = 0 ;
86930
86931   {
86932     try {
86933       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86934     } catch (std::out_of_range& e) {
86935       {
86936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86937       };
86938     } catch (std::exception& e) {
86939       {
86940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86941       };
86942     } catch (Dali::DaliException e) {
86943       {
86944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86945       };
86946     } catch (...) {
86947       {
86948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86949       };
86950     }
86951   }
86952
86953   jresult = (void *)result;
86954   return jresult;
86955 }
86956
86957
86958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86959   void * jresult ;
86960   Dali::Toolkit::Slider *arg1 = 0 ;
86961   Dali::Toolkit::Slider *result = 0 ;
86962
86963   arg1 = (Dali::Toolkit::Slider *)jarg1;
86964   if (!arg1) {
86965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86966     return 0;
86967   }
86968   {
86969     try {
86970       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86971     } catch (std::out_of_range& e) {
86972       {
86973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86974       };
86975     } catch (std::exception& e) {
86976       {
86977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86978       };
86979     } catch (Dali::DaliException e) {
86980       {
86981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86982       };
86983     } catch (...) {
86984       {
86985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86986       };
86987     }
86988   }
86989
86990   jresult = (void *)result;
86991   return jresult;
86992 }
86993
86994
86995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86996   void * jresult ;
86997   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86998   Dali::Toolkit::Slider *arg2 = 0 ;
86999   Dali::Toolkit::Slider *result = 0 ;
87000
87001   arg1 = (Dali::Toolkit::Slider *)jarg1;
87002   arg2 = (Dali::Toolkit::Slider *)jarg2;
87003   if (!arg2) {
87004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87005     return 0;
87006   }
87007   {
87008     try {
87009       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87010     } catch (std::out_of_range& e) {
87011       {
87012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87013       };
87014     } catch (std::exception& e) {
87015       {
87016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87017       };
87018     } catch (Dali::DaliException e) {
87019       {
87020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87021       };
87022     } catch (...) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87025       };
87026     }
87027   }
87028
87029   jresult = (void *)result;
87030   return jresult;
87031 }
87032
87033
87034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87035   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87036
87037   arg1 = (Dali::Toolkit::Slider *)jarg1;
87038   {
87039     try {
87040       delete arg1;
87041     } catch (std::out_of_range& e) {
87042       {
87043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87044       };
87045     } catch (std::exception& e) {
87046       {
87047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87048       };
87049     } catch (Dali::DaliException e) {
87050       {
87051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87052       };
87053     } catch (...) {
87054       {
87055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87056       };
87057     }
87058   }
87059
87060 }
87061
87062
87063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87064   void * jresult ;
87065   Dali::BaseHandle arg1 ;
87066   Dali::BaseHandle *argp1 ;
87067   Dali::Toolkit::Slider result;
87068
87069   argp1 = (Dali::BaseHandle *)jarg1;
87070   if (!argp1) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87072     return 0;
87073   }
87074   arg1 = *argp1;
87075   {
87076     try {
87077       result = Dali::Toolkit::Slider::DownCast(arg1);
87078     } catch (std::out_of_range& e) {
87079       {
87080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (std::exception& e) {
87083       {
87084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (Dali::DaliException e) {
87087       {
87088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87093       };
87094     }
87095   }
87096
87097   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87098   return jresult;
87099 }
87100
87101
87102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87103   void * jresult ;
87104   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87105   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87106
87107   arg1 = (Dali::Toolkit::Slider *)jarg1;
87108   {
87109     try {
87110       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87111     } catch (std::out_of_range& e) {
87112       {
87113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87114       };
87115     } catch (std::exception& e) {
87116       {
87117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87118       };
87119     } catch (Dali::DaliException e) {
87120       {
87121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87122       };
87123     } catch (...) {
87124       {
87125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87126       };
87127     }
87128   }
87129
87130   jresult = (void *)result;
87131   return jresult;
87132 }
87133
87134
87135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87136   void * jresult ;
87137   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87138   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87139
87140   arg1 = (Dali::Toolkit::Slider *)jarg1;
87141   {
87142     try {
87143       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87144     } catch (std::out_of_range& e) {
87145       {
87146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87147       };
87148     } catch (std::exception& e) {
87149       {
87150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87151       };
87152     } catch (Dali::DaliException e) {
87153       {
87154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87155       };
87156     } catch (...) {
87157       {
87158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87159       };
87160     }
87161   }
87162
87163   jresult = (void *)result;
87164   return jresult;
87165 }
87166
87167
87168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87169   void * jresult ;
87170   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87171   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87172
87173   arg1 = (Dali::Toolkit::Slider *)jarg1;
87174   {
87175     try {
87176       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87184       };
87185     } catch (Dali::DaliException e) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87188       };
87189     } catch (...) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87192       };
87193     }
87194   }
87195
87196   jresult = (void *)result;
87197   return jresult;
87198 }
87199
87200
87201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87202   int jresult ;
87203   int result;
87204
87205   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87206   jresult = (int)result;
87207   return jresult;
87208 }
87209
87210
87211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87212   int jresult ;
87213   int result;
87214
87215   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87216   jresult = (int)result;
87217   return jresult;
87218 }
87219
87220
87221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87222   int jresult ;
87223   int result;
87224
87225   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87226   jresult = (int)result;
87227   return jresult;
87228 }
87229
87230
87231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87232   int jresult ;
87233   int result;
87234
87235   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87236   jresult = (int)result;
87237   return jresult;
87238 }
87239
87240
87241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87242   int result;
87243
87244   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87245
87246   return result;
87247 }
87248
87249
87250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87251   void * jresult ;
87252   Dali::Toolkit::VideoView::Property *result = 0 ;
87253
87254   {
87255     try {
87256       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87257     } catch (std::out_of_range& e) {
87258       {
87259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87260       };
87261     } catch (std::exception& e) {
87262       {
87263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87264       };
87265     } catch (Dali::DaliException e) {
87266       {
87267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87268       };
87269     } catch (...) {
87270       {
87271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87272       };
87273     }
87274   }
87275
87276   jresult = (void *)result;
87277   return jresult;
87278 }
87279
87280
87281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87282   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87283
87284   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87285   {
87286     try {
87287       delete arg1;
87288     } catch (std::out_of_range& e) {
87289       {
87290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (std::exception& e) {
87293       {
87294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (Dali::DaliException e) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87299       };
87300     } catch (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87303       };
87304     }
87305   }
87306
87307 }
87308
87309
87310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87311   void * jresult ;
87312   Dali::Toolkit::VideoView result;
87313
87314   {
87315     try {
87316       result = Dali::Toolkit::VideoView::New();
87317     } catch (std::out_of_range& e) {
87318       {
87319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87320       };
87321     } catch (std::exception& e) {
87322       {
87323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87324       };
87325     } catch (Dali::DaliException e) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87332       };
87333     }
87334   }
87335
87336   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87337   return jresult;
87338 }
87339
87340
87341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87342   void * jresult ;
87343   std::string *arg1 = 0 ;
87344   Dali::Toolkit::VideoView result;
87345
87346   if (!jarg1) {
87347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87348     return 0;
87349   }
87350   std::string arg1_str(jarg1);
87351   arg1 = &arg1_str;
87352   {
87353     try {
87354       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87355     } catch (std::out_of_range& e) {
87356       {
87357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87358       };
87359     } catch (std::exception& e) {
87360       {
87361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87362       };
87363     } catch (Dali::DaliException e) {
87364       {
87365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87366       };
87367     } catch (...) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87370       };
87371     }
87372   }
87373
87374   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87375
87376   //argout typemap for const std::string&
87377
87378   return jresult;
87379 }
87380
87381
87382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87383   void * jresult ;
87384   Dali::Toolkit::VideoView *result = 0 ;
87385
87386   {
87387     try {
87388       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87389     } catch (std::out_of_range& e) {
87390       {
87391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87392       };
87393     } catch (std::exception& e) {
87394       {
87395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87396       };
87397     } catch (Dali::DaliException e) {
87398       {
87399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87400       };
87401     } catch (...) {
87402       {
87403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87404       };
87405     }
87406   }
87407
87408   jresult = (void *)result;
87409   return jresult;
87410 }
87411
87412
87413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87414   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87415
87416   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87417   {
87418     try {
87419       delete arg1;
87420     } catch (std::out_of_range& e) {
87421       {
87422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87423       };
87424     } catch (std::exception& e) {
87425       {
87426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87427       };
87428     } catch (Dali::DaliException e) {
87429       {
87430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87431       };
87432     } catch (...) {
87433       {
87434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87435       };
87436     }
87437   }
87438
87439 }
87440
87441
87442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87443   void * jresult ;
87444   Dali::Toolkit::VideoView *arg1 = 0 ;
87445   Dali::Toolkit::VideoView *result = 0 ;
87446
87447   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87448   if (!arg1) {
87449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87450     return 0;
87451   }
87452   {
87453     try {
87454       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87455     } catch (std::out_of_range& e) {
87456       {
87457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87458       };
87459     } catch (std::exception& e) {
87460       {
87461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87462       };
87463     } catch (Dali::DaliException e) {
87464       {
87465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87466       };
87467     } catch (...) {
87468       {
87469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87470       };
87471     }
87472   }
87473
87474   jresult = (void *)result;
87475   return jresult;
87476 }
87477
87478
87479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87480   void * jresult ;
87481   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87482   Dali::Toolkit::VideoView *arg2 = 0 ;
87483   Dali::Toolkit::VideoView *result = 0 ;
87484
87485   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87486   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87487   if (!arg2) {
87488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87489     return 0;
87490   }
87491   {
87492     try {
87493       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87494     } catch (std::out_of_range& e) {
87495       {
87496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87497       };
87498     } catch (std::exception& e) {
87499       {
87500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87501       };
87502     } catch (Dali::DaliException e) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87505       };
87506     } catch (...) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87509       };
87510     }
87511   }
87512
87513   jresult = (void *)result;
87514   return jresult;
87515 }
87516
87517
87518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87519   void * jresult ;
87520   Dali::BaseHandle arg1 ;
87521   Dali::BaseHandle *argp1 ;
87522   Dali::Toolkit::VideoView result;
87523
87524   argp1 = (Dali::BaseHandle *)jarg1;
87525   if (!argp1) {
87526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87527     return 0;
87528   }
87529   arg1 = *argp1;
87530   {
87531     try {
87532       result = Dali::Toolkit::VideoView::DownCast(arg1);
87533     } catch (std::out_of_range& e) {
87534       {
87535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87536       };
87537     } catch (std::exception& e) {
87538       {
87539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87540       };
87541     } catch (Dali::DaliException e) {
87542       {
87543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87544       };
87545     } catch (...) {
87546       {
87547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87548       };
87549     }
87550   }
87551
87552   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87553   return jresult;
87554 }
87555
87556
87557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87558   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87559
87560   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87561   {
87562     try {
87563       (arg1)->Play();
87564     } catch (std::out_of_range& e) {
87565       {
87566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87567       };
87568     } catch (std::exception& e) {
87569       {
87570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87571       };
87572     } catch (Dali::DaliException e) {
87573       {
87574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87575       };
87576     } catch (...) {
87577       {
87578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87579       };
87580     }
87581   }
87582
87583 }
87584
87585
87586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87587   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87588
87589   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87590   {
87591     try {
87592       (arg1)->Pause();
87593     } catch (std::out_of_range& e) {
87594       {
87595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87596       };
87597     } catch (std::exception& e) {
87598       {
87599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87600       };
87601     } catch (Dali::DaliException e) {
87602       {
87603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87604       };
87605     } catch (...) {
87606       {
87607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87608       };
87609     }
87610   }
87611
87612 }
87613
87614
87615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87616   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87617
87618   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87619   {
87620     try {
87621       (arg1)->Stop();
87622     } catch (std::out_of_range& e) {
87623       {
87624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87625       };
87626     } catch (std::exception& e) {
87627       {
87628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87629       };
87630     } catch (Dali::DaliException e) {
87631       {
87632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87633       };
87634     } catch (...) {
87635       {
87636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87637       };
87638     }
87639   }
87640
87641 }
87642
87643
87644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87645   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87646   int arg2 ;
87647
87648   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87649   arg2 = (int)jarg2;
87650   {
87651     try {
87652       (arg1)->Forward(arg2);
87653     } catch (std::out_of_range& e) {
87654       {
87655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87656       };
87657     } catch (std::exception& e) {
87658       {
87659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87660       };
87661     } catch (Dali::DaliException e) {
87662       {
87663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87668       };
87669     }
87670   }
87671
87672 }
87673
87674
87675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87676   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87677   int arg2 ;
87678
87679   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87680   arg2 = (int)jarg2;
87681   {
87682     try {
87683       (arg1)->Backward(arg2);
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (Dali::DaliException e) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87695       };
87696     } catch (...) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87699       };
87700     }
87701   }
87702
87703 }
87704
87705
87706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87707   void * jresult ;
87708   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87709   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87710
87711   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87712   {
87713     try {
87714       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87715     } catch (std::out_of_range& e) {
87716       {
87717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87718       };
87719     } catch (std::exception& e) {
87720       {
87721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (Dali::DaliException e) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87730       };
87731     }
87732   }
87733
87734   jresult = (void *)result;
87735   return jresult;
87736 }
87737
87738
87739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87740   int jresult ;
87741   int result;
87742
87743   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87744   jresult = (int)result;
87745   return jresult;
87746 }
87747
87748
87749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87750   int jresult ;
87751   int result;
87752
87753   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87754   jresult = (int)result;
87755   return jresult;
87756 }
87757
87758
87759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87760   int jresult ;
87761   int result;
87762
87763   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87764   jresult = (int)result;
87765   return jresult;
87766 }
87767
87768
87769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87770   int jresult ;
87771   int result;
87772
87773   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87774   jresult = (int)result;
87775   return jresult;
87776 }
87777
87778
87779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87780   int jresult ;
87781   int result;
87782
87783   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87784   jresult = (int)result;
87785   return jresult;
87786 }
87787
87788
87789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87790   int jresult ;
87791   int result;
87792
87793   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87794   jresult = (int)result;
87795   return jresult;
87796 }
87797
87798
87799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87800   int jresult ;
87801   int result;
87802
87803   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87804   jresult = (int)result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87810   int jresult ;
87811   int result;
87812
87813   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87814   jresult = (int)result;
87815   return jresult;
87816 }
87817
87818
87819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87820   int jresult ;
87821   int result;
87822
87823   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87824   jresult = (int)result;
87825   return jresult;
87826 }
87827
87828
87829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87830   int jresult ;
87831   int result;
87832
87833   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87834   jresult = (int)result;
87835   return jresult;
87836 }
87837
87838
87839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87840   int jresult ;
87841   int result;
87842
87843   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87844   jresult = (int)result;
87845   return jresult;
87846 }
87847
87848
87849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87850   int jresult ;
87851   int result;
87852
87853   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87854   jresult = (int)result;
87855   return jresult;
87856 }
87857
87858
87859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87860   int jresult ;
87861   int result;
87862
87863   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87864   jresult = (int)result;
87865   return jresult;
87866 }
87867
87868
87869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87870   int jresult ;
87871   int result;
87872
87873   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87874   jresult = (int)result;
87875   return jresult;
87876 }
87877
87878
87879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87880   int jresult ;
87881   int result;
87882
87883   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87884   jresult = (int)result;
87885   return jresult;
87886 }
87887
87888
87889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87890   int jresult ;
87891   int result;
87892
87893   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87894   jresult = (int)result;
87895   return jresult;
87896 }
87897
87898
87899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87900   int jresult ;
87901   int result;
87902
87903   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87904   jresult = (int)result;
87905   return jresult;
87906 }
87907
87908
87909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87910   int jresult ;
87911   int result;
87912
87913   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87914   jresult = (int)result;
87915   return jresult;
87916 }
87917
87918
87919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87920   int jresult ;
87921   int result;
87922
87923   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87924   jresult = (int)result;
87925   return jresult;
87926 }
87927
87928
87929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87930   int jresult ;
87931   int result;
87932
87933   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87934   jresult = (int)result;
87935   return jresult;
87936 }
87937
87938
87939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87940   int jresult ;
87941   int result;
87942
87943   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87944   jresult = (int)result;
87945   return jresult;
87946 }
87947
87948
87949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87950   void * jresult ;
87951   Dali::Toolkit::Popup::Property *result = 0 ;
87952
87953   {
87954     try {
87955       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (Dali::DaliException e) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87971       };
87972     }
87973   }
87974
87975   jresult = (void *)result;
87976   return jresult;
87977 }
87978
87979
87980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87981   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87982
87983   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87984   {
87985     try {
87986       delete arg1;
87987     } catch (std::out_of_range& e) {
87988       {
87989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87990       };
87991     } catch (std::exception& e) {
87992       {
87993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87994       };
87995     } catch (Dali::DaliException e) {
87996       {
87997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88002       };
88003     }
88004   }
88005
88006 }
88007
88008
88009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88010   void * jresult ;
88011   Dali::Toolkit::Popup *result = 0 ;
88012
88013   {
88014     try {
88015       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88016     } catch (std::out_of_range& e) {
88017       {
88018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (std::exception& e) {
88021       {
88022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88023       };
88024     } catch (Dali::DaliException e) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88027       };
88028     } catch (...) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88031       };
88032     }
88033   }
88034
88035   jresult = (void *)result;
88036   return jresult;
88037 }
88038
88039
88040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88041   void * jresult ;
88042   Dali::Toolkit::Popup result;
88043
88044   {
88045     try {
88046       result = Dali::Toolkit::Popup::New();
88047     } catch (std::out_of_range& e) {
88048       {
88049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88050       };
88051     } catch (std::exception& e) {
88052       {
88053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88054       };
88055     } catch (Dali::DaliException e) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88058       };
88059     } catch (...) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88062       };
88063     }
88064   }
88065
88066   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88067   return jresult;
88068 }
88069
88070
88071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88072   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88073
88074   arg1 = (Dali::Toolkit::Popup *)jarg1;
88075   {
88076     try {
88077       delete arg1;
88078     } catch (std::out_of_range& e) {
88079       {
88080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88081       };
88082     } catch (std::exception& e) {
88083       {
88084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (Dali::DaliException e) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88089       };
88090     } catch (...) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88093       };
88094     }
88095   }
88096
88097 }
88098
88099
88100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88101   void * jresult ;
88102   Dali::Toolkit::Popup *arg1 = 0 ;
88103   Dali::Toolkit::Popup *result = 0 ;
88104
88105   arg1 = (Dali::Toolkit::Popup *)jarg1;
88106   if (!arg1) {
88107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88108     return 0;
88109   }
88110   {
88111     try {
88112       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88113     } catch (std::out_of_range& e) {
88114       {
88115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88116       };
88117     } catch (std::exception& e) {
88118       {
88119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (Dali::DaliException e) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88124       };
88125     } catch (...) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88128       };
88129     }
88130   }
88131
88132   jresult = (void *)result;
88133   return jresult;
88134 }
88135
88136
88137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88138   void * jresult ;
88139   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88140   Dali::Toolkit::Popup *arg2 = 0 ;
88141   Dali::Toolkit::Popup *result = 0 ;
88142
88143   arg1 = (Dali::Toolkit::Popup *)jarg1;
88144   arg2 = (Dali::Toolkit::Popup *)jarg2;
88145   if (!arg2) {
88146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88147     return 0;
88148   }
88149   {
88150     try {
88151       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88152     } catch (std::out_of_range& e) {
88153       {
88154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88155       };
88156     } catch (std::exception& e) {
88157       {
88158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88159       };
88160     } catch (Dali::DaliException e) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88163       };
88164     } catch (...) {
88165       {
88166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88167       };
88168     }
88169   }
88170
88171   jresult = (void *)result;
88172   return jresult;
88173 }
88174
88175
88176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88177   void * jresult ;
88178   Dali::BaseHandle arg1 ;
88179   Dali::BaseHandle *argp1 ;
88180   Dali::Toolkit::Popup result;
88181
88182   argp1 = (Dali::BaseHandle *)jarg1;
88183   if (!argp1) {
88184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88185     return 0;
88186   }
88187   arg1 = *argp1;
88188   {
88189     try {
88190       result = Dali::Toolkit::Popup::DownCast(arg1);
88191     } catch (std::out_of_range& e) {
88192       {
88193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88194       };
88195     } catch (std::exception& e) {
88196       {
88197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88198       };
88199     } catch (Dali::DaliException e) {
88200       {
88201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88202       };
88203     } catch (...) {
88204       {
88205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88206       };
88207     }
88208   }
88209
88210   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88211   return jresult;
88212 }
88213
88214
88215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88216   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88217   Dali::Actor arg2 ;
88218   Dali::Actor *argp2 ;
88219
88220   arg1 = (Dali::Toolkit::Popup *)jarg1;
88221   argp2 = (Dali::Actor *)jarg2;
88222   if (!argp2) {
88223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88224     return ;
88225   }
88226   arg2 = *argp2;
88227   {
88228     try {
88229       (arg1)->SetTitle(arg2);
88230     } catch (std::out_of_range& e) {
88231       {
88232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88233       };
88234     } catch (std::exception& e) {
88235       {
88236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (Dali::DaliException e) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88241       };
88242     } catch (...) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88245       };
88246     }
88247   }
88248
88249 }
88250
88251
88252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88253   void * jresult ;
88254   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88255   Dali::Actor result;
88256
88257   arg1 = (Dali::Toolkit::Popup *)jarg1;
88258   {
88259     try {
88260       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88261     } catch (std::out_of_range& e) {
88262       {
88263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88264       };
88265     } catch (std::exception& e) {
88266       {
88267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88268       };
88269     } catch (Dali::DaliException e) {
88270       {
88271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88272       };
88273     } catch (...) {
88274       {
88275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88276       };
88277     }
88278   }
88279
88280   jresult = new Dali::Actor((const Dali::Actor &)result);
88281   return jresult;
88282 }
88283
88284
88285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88286   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88287   Dali::Actor arg2 ;
88288   Dali::Actor *argp2 ;
88289
88290   arg1 = (Dali::Toolkit::Popup *)jarg1;
88291   argp2 = (Dali::Actor *)jarg2;
88292   if (!argp2) {
88293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88294     return ;
88295   }
88296   arg2 = *argp2;
88297   {
88298     try {
88299       (arg1)->SetContent(arg2);
88300     } catch (std::out_of_range& e) {
88301       {
88302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88303       };
88304     } catch (std::exception& e) {
88305       {
88306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88307       };
88308     } catch (Dali::DaliException e) {
88309       {
88310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88311       };
88312     } catch (...) {
88313       {
88314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88315       };
88316     }
88317   }
88318
88319 }
88320
88321
88322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88323   void * jresult ;
88324   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88325   Dali::Actor result;
88326
88327   arg1 = (Dali::Toolkit::Popup *)jarg1;
88328   {
88329     try {
88330       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88331     } catch (std::out_of_range& e) {
88332       {
88333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88334       };
88335     } catch (std::exception& e) {
88336       {
88337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88338       };
88339     } catch (Dali::DaliException e) {
88340       {
88341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88342       };
88343     } catch (...) {
88344       {
88345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88346       };
88347     }
88348   }
88349
88350   jresult = new Dali::Actor((const Dali::Actor &)result);
88351   return jresult;
88352 }
88353
88354
88355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88356   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88357   Dali::Actor arg2 ;
88358   Dali::Actor *argp2 ;
88359
88360   arg1 = (Dali::Toolkit::Popup *)jarg1;
88361   argp2 = (Dali::Actor *)jarg2;
88362   if (!argp2) {
88363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88364     return ;
88365   }
88366   arg2 = *argp2;
88367   {
88368     try {
88369       (arg1)->SetFooter(arg2);
88370     } catch (std::out_of_range& e) {
88371       {
88372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88373       };
88374     } catch (std::exception& e) {
88375       {
88376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88377       };
88378     } catch (Dali::DaliException e) {
88379       {
88380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88381       };
88382     } catch (...) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88385       };
88386     }
88387   }
88388
88389 }
88390
88391
88392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88393   void * jresult ;
88394   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88395   Dali::Actor result;
88396
88397   arg1 = (Dali::Toolkit::Popup *)jarg1;
88398   {
88399     try {
88400       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88401     } catch (std::out_of_range& e) {
88402       {
88403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88404       };
88405     } catch (std::exception& e) {
88406       {
88407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88408       };
88409     } catch (Dali::DaliException e) {
88410       {
88411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88412       };
88413     } catch (...) {
88414       {
88415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88416       };
88417     }
88418   }
88419
88420   jresult = new Dali::Actor((const Dali::Actor &)result);
88421   return jresult;
88422 }
88423
88424
88425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88426   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88427   Dali::Toolkit::Popup::DisplayState arg2 ;
88428
88429   arg1 = (Dali::Toolkit::Popup *)jarg1;
88430   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88431   {
88432     try {
88433       (arg1)->SetDisplayState(arg2);
88434     } catch (std::out_of_range& e) {
88435       {
88436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88437       };
88438     } catch (std::exception& e) {
88439       {
88440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88441       };
88442     } catch (Dali::DaliException e) {
88443       {
88444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88445       };
88446     } catch (...) {
88447       {
88448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88449       };
88450     }
88451   }
88452
88453 }
88454
88455
88456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88457   int jresult ;
88458   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88459   Dali::Toolkit::Popup::DisplayState result;
88460
88461   arg1 = (Dali::Toolkit::Popup *)jarg1;
88462   {
88463     try {
88464       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88465     } catch (std::out_of_range& e) {
88466       {
88467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88468       };
88469     } catch (std::exception& e) {
88470       {
88471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88472       };
88473     } catch (Dali::DaliException e) {
88474       {
88475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88476       };
88477     } catch (...) {
88478       {
88479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88480       };
88481     }
88482   }
88483
88484   jresult = (int)result;
88485   return jresult;
88486 }
88487
88488
88489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88490   void * jresult ;
88491   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88492   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88493
88494   arg1 = (Dali::Toolkit::Popup *)jarg1;
88495   {
88496     try {
88497       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88498     } catch (std::out_of_range& e) {
88499       {
88500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88501       };
88502     } catch (std::exception& e) {
88503       {
88504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88505       };
88506     } catch (Dali::DaliException e) {
88507       {
88508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88509       };
88510     } catch (...) {
88511       {
88512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88513       };
88514     }
88515   }
88516
88517   jresult = (void *)result;
88518   return jresult;
88519 }
88520
88521
88522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88523   void * jresult ;
88524   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88525   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88526
88527   arg1 = (Dali::Toolkit::Popup *)jarg1;
88528   {
88529     try {
88530       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88531     } catch (std::out_of_range& e) {
88532       {
88533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88534       };
88535     } catch (std::exception& e) {
88536       {
88537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88538       };
88539     } catch (Dali::DaliException e) {
88540       {
88541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88542       };
88543     } catch (...) {
88544       {
88545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88546       };
88547     }
88548   }
88549
88550   jresult = (void *)result;
88551   return jresult;
88552 }
88553
88554
88555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88556   void * jresult ;
88557   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88558   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88559
88560   arg1 = (Dali::Toolkit::Popup *)jarg1;
88561   {
88562     try {
88563       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88564     } catch (std::out_of_range& e) {
88565       {
88566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88567       };
88568     } catch (std::exception& e) {
88569       {
88570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (Dali::DaliException e) {
88573       {
88574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88575       };
88576     } catch (...) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88579       };
88580     }
88581   }
88582
88583   jresult = (void *)result;
88584   return jresult;
88585 }
88586
88587
88588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88589   void * jresult ;
88590   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88591   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88592
88593   arg1 = (Dali::Toolkit::Popup *)jarg1;
88594   {
88595     try {
88596       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88597     } catch (std::out_of_range& e) {
88598       {
88599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88600       };
88601     } catch (std::exception& e) {
88602       {
88603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (Dali::DaliException e) {
88606       {
88607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88612       };
88613     }
88614   }
88615
88616   jresult = (void *)result;
88617   return jresult;
88618 }
88619
88620
88621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88622   void * jresult ;
88623   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88624   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88625
88626   arg1 = (Dali::Toolkit::Popup *)jarg1;
88627   {
88628     try {
88629       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88630     } catch (std::out_of_range& e) {
88631       {
88632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (std::exception& e) {
88635       {
88636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88637       };
88638     } catch (Dali::DaliException e) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88645       };
88646     }
88647   }
88648
88649   jresult = (void *)result;
88650   return jresult;
88651 }
88652
88653
88654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88655   int jresult ;
88656   int result;
88657
88658   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88659   jresult = (int)result;
88660   return jresult;
88661 }
88662
88663
88664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88665   int jresult ;
88666   int result;
88667
88668   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88669   jresult = (int)result;
88670   return jresult;
88671 }
88672
88673
88674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88675   int jresult ;
88676   int result;
88677
88678   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88679   jresult = (int)result;
88680   return jresult;
88681 }
88682
88683
88684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88685   int jresult ;
88686   int result;
88687
88688   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88689   jresult = (int)result;
88690   return jresult;
88691 }
88692
88693
88694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88695   int jresult ;
88696   int result;
88697
88698   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88699   jresult = (int)result;
88700   return jresult;
88701 }
88702
88703
88704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88705   int jresult ;
88706   int result;
88707
88708   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88709   jresult = (int)result;
88710   return jresult;
88711 }
88712
88713
88714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88715   int jresult ;
88716   int result;
88717
88718   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88719   jresult = (int)result;
88720   return jresult;
88721 }
88722
88723
88724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88725   int jresult ;
88726   int result;
88727
88728   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88729   jresult = (int)result;
88730   return jresult;
88731 }
88732
88733
88734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88735   int jresult ;
88736   int result;
88737
88738   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88739   jresult = (int)result;
88740   return jresult;
88741 }
88742
88743
88744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88745   void * jresult ;
88746   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88747
88748   {
88749     try {
88750       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88751     } catch (std::out_of_range& e) {
88752       {
88753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88754       };
88755     } catch (std::exception& e) {
88756       {
88757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (Dali::DaliException e) {
88760       {
88761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88762       };
88763     } catch (...) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88766       };
88767     }
88768   }
88769
88770   jresult = (void *)result;
88771   return jresult;
88772 }
88773
88774
88775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88776   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88777
88778   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88779   {
88780     try {
88781       delete arg1;
88782     } catch (std::out_of_range& e) {
88783       {
88784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88785       };
88786     } catch (std::exception& e) {
88787       {
88788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88789       };
88790     } catch (Dali::DaliException e) {
88791       {
88792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88793       };
88794     } catch (...) {
88795       {
88796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88797       };
88798     }
88799   }
88800
88801 }
88802
88803
88804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88805   void * jresult ;
88806   Dali::Toolkit::ProgressBar result;
88807
88808   {
88809     try {
88810       result = Dali::Toolkit::ProgressBar::New();
88811     } catch (std::out_of_range& e) {
88812       {
88813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88814       };
88815     } catch (std::exception& e) {
88816       {
88817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88818       };
88819     } catch (Dali::DaliException e) {
88820       {
88821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88822       };
88823     } catch (...) {
88824       {
88825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88826       };
88827     }
88828   }
88829
88830   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88831   return jresult;
88832 }
88833
88834
88835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88836   void * jresult ;
88837   Dali::Toolkit::ProgressBar *result = 0 ;
88838
88839   {
88840     try {
88841       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (Dali::DaliException e) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88853       };
88854     } catch (...) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88857       };
88858     }
88859   }
88860
88861   jresult = (void *)result;
88862   return jresult;
88863 }
88864
88865
88866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88867   void * jresult ;
88868   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88869   Dali::Toolkit::ProgressBar *result = 0 ;
88870
88871   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88872   if (!arg1) {
88873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88874     return 0;
88875   }
88876   {
88877     try {
88878       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88879     } catch (std::out_of_range& e) {
88880       {
88881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88882       };
88883     } catch (std::exception& e) {
88884       {
88885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88886       };
88887     } catch (Dali::DaliException e) {
88888       {
88889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88890       };
88891     } catch (...) {
88892       {
88893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88894       };
88895     }
88896   }
88897
88898   jresult = (void *)result;
88899   return jresult;
88900 }
88901
88902
88903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88904   void * jresult ;
88905   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88906   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88907   Dali::Toolkit::ProgressBar *result = 0 ;
88908
88909   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88910   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88911   if (!arg2) {
88912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88913     return 0;
88914   }
88915   {
88916     try {
88917       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88918     } catch (std::out_of_range& e) {
88919       {
88920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88921       };
88922     } catch (std::exception& e) {
88923       {
88924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88925       };
88926     } catch (Dali::DaliException e) {
88927       {
88928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88933       };
88934     }
88935   }
88936
88937   jresult = (void *)result;
88938   return jresult;
88939 }
88940
88941
88942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88943   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88944
88945   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88946   {
88947     try {
88948       delete arg1;
88949     } catch (std::out_of_range& e) {
88950       {
88951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88952       };
88953     } catch (std::exception& e) {
88954       {
88955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88956       };
88957     } catch (Dali::DaliException e) {
88958       {
88959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88960       };
88961     } catch (...) {
88962       {
88963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88964       };
88965     }
88966   }
88967
88968 }
88969
88970
88971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88972   void * jresult ;
88973   Dali::BaseHandle arg1 ;
88974   Dali::BaseHandle *argp1 ;
88975   Dali::Toolkit::ProgressBar result;
88976
88977   argp1 = (Dali::BaseHandle *)jarg1;
88978   if (!argp1) {
88979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88980     return 0;
88981   }
88982   arg1 = *argp1;
88983   {
88984     try {
88985       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88986     } catch (std::out_of_range& e) {
88987       {
88988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88989       };
88990     } catch (std::exception& e) {
88991       {
88992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88993       };
88994     } catch (Dali::DaliException e) {
88995       {
88996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88997       };
88998     } catch (...) {
88999       {
89000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89001       };
89002     }
89003   }
89004
89005   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89006   return jresult;
89007 }
89008
89009
89010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89011   void * jresult ;
89012   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89013   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89014
89015   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89016   {
89017     try {
89018       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89019     } catch (std::out_of_range& e) {
89020       {
89021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89022       };
89023     } catch (std::exception& e) {
89024       {
89025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89026       };
89027     } catch (Dali::DaliException e) {
89028       {
89029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89030       };
89031     } catch (...) {
89032       {
89033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89034       };
89035     }
89036   }
89037
89038   jresult = (void *)result;
89039   return jresult;
89040 }
89041
89042
89043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89044   void * jresult ;
89045   Dali::Toolkit::GaussianBlurView *result = 0 ;
89046
89047   {
89048     try {
89049       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89050     } catch (std::out_of_range& e) {
89051       {
89052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89053       };
89054     } catch (std::exception& e) {
89055       {
89056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89057       };
89058     } catch (Dali::DaliException e) {
89059       {
89060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89061       };
89062     } catch (...) {
89063       {
89064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89065       };
89066     }
89067   }
89068
89069   jresult = (void *)result;
89070   return jresult;
89071 }
89072
89073
89074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89075   void * jresult ;
89076   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89077   Dali::Toolkit::GaussianBlurView *result = 0 ;
89078
89079   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89080   if (!arg1) {
89081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89082     return 0;
89083   }
89084   {
89085     try {
89086       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89087     } catch (std::out_of_range& e) {
89088       {
89089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89090       };
89091     } catch (std::exception& e) {
89092       {
89093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89094       };
89095     } catch (Dali::DaliException e) {
89096       {
89097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89098       };
89099     } catch (...) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89102       };
89103     }
89104   }
89105
89106   jresult = (void *)result;
89107   return jresult;
89108 }
89109
89110
89111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89112   void * jresult ;
89113   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89114   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89115   Dali::Toolkit::GaussianBlurView *result = 0 ;
89116
89117   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89118   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89119   if (!arg2) {
89120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89121     return 0;
89122   }
89123   {
89124     try {
89125       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89126     } catch (std::out_of_range& e) {
89127       {
89128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89129       };
89130     } catch (std::exception& e) {
89131       {
89132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (Dali::DaliException e) {
89135       {
89136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89137       };
89138     } catch (...) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89141       };
89142     }
89143   }
89144
89145   jresult = (void *)result;
89146   return jresult;
89147 }
89148
89149
89150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89151   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89152
89153   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89154   {
89155     try {
89156       delete arg1;
89157     } catch (std::out_of_range& e) {
89158       {
89159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89160       };
89161     } catch (std::exception& e) {
89162       {
89163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89164       };
89165     } catch (Dali::DaliException e) {
89166       {
89167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89168       };
89169     } catch (...) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89172       };
89173     }
89174   }
89175
89176 }
89177
89178
89179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89180   void * jresult ;
89181   Dali::BaseHandle arg1 ;
89182   Dali::BaseHandle *argp1 ;
89183   Dali::Toolkit::GaussianBlurView result;
89184
89185   argp1 = (Dali::BaseHandle *)jarg1;
89186   if (!argp1) {
89187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89188     return 0;
89189   }
89190   arg1 = *argp1;
89191   {
89192     try {
89193       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89194     } catch (std::out_of_range& e) {
89195       {
89196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89197       };
89198     } catch (std::exception& e) {
89199       {
89200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (Dali::DaliException e) {
89203       {
89204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89205       };
89206     } catch (...) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89209       };
89210     }
89211   }
89212
89213   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89214   return jresult;
89215 }
89216
89217
89218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89219   void * jresult ;
89220   Dali::Toolkit::GaussianBlurView result;
89221
89222   {
89223     try {
89224       result = Dali::Toolkit::GaussianBlurView::New();
89225     } catch (std::out_of_range& e) {
89226       {
89227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89228       };
89229     } catch (std::exception& e) {
89230       {
89231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89232       };
89233     } catch (Dali::DaliException e) {
89234       {
89235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89236       };
89237     } catch (...) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89240       };
89241     }
89242   }
89243
89244   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89245   return jresult;
89246 }
89247
89248
89249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89250   void * jresult ;
89251   unsigned int arg1 ;
89252   float arg2 ;
89253   Dali::Pixel::Format arg3 ;
89254   float arg4 ;
89255   float arg5 ;
89256   bool arg6 ;
89257   Dali::Toolkit::GaussianBlurView result;
89258
89259   arg1 = (unsigned int)jarg1;
89260   arg2 = (float)jarg2;
89261   arg3 = (Dali::Pixel::Format)jarg3;
89262   arg4 = (float)jarg4;
89263   arg5 = (float)jarg5;
89264   arg6 = jarg6 ? true : false;
89265   {
89266     try {
89267       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89268     } catch (std::out_of_range& e) {
89269       {
89270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89271       };
89272     } catch (std::exception& e) {
89273       {
89274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89275       };
89276     } catch (Dali::DaliException e) {
89277       {
89278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89279       };
89280     } catch (...) {
89281       {
89282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89283       };
89284     }
89285   }
89286
89287   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89288   return jresult;
89289 }
89290
89291
89292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89293   void * jresult ;
89294   unsigned int arg1 ;
89295   float arg2 ;
89296   Dali::Pixel::Format arg3 ;
89297   float arg4 ;
89298   float arg5 ;
89299   Dali::Toolkit::GaussianBlurView result;
89300
89301   arg1 = (unsigned int)jarg1;
89302   arg2 = (float)jarg2;
89303   arg3 = (Dali::Pixel::Format)jarg3;
89304   arg4 = (float)jarg4;
89305   arg5 = (float)jarg5;
89306   {
89307     try {
89308       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89309     } catch (std::out_of_range& e) {
89310       {
89311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89312       };
89313     } catch (std::exception& e) {
89314       {
89315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89316       };
89317     } catch (Dali::DaliException e) {
89318       {
89319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89320       };
89321     } catch (...) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89324       };
89325     }
89326   }
89327
89328   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89329   return jresult;
89330 }
89331
89332
89333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89334   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89335   Dali::Actor arg2 ;
89336   Dali::Actor *argp2 ;
89337
89338   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89339   argp2 = (Dali::Actor *)jarg2;
89340   if (!argp2) {
89341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89342     return ;
89343   }
89344   arg2 = *argp2;
89345   {
89346     try {
89347       (arg1)->Add(arg2);
89348     } catch (std::out_of_range& e) {
89349       {
89350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89351       };
89352     } catch (std::exception& e) {
89353       {
89354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89355       };
89356     } catch (Dali::DaliException e) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89359       };
89360     } catch (...) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89363       };
89364     }
89365   }
89366
89367 }
89368
89369
89370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89371   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89372   Dali::Actor arg2 ;
89373   Dali::Actor *argp2 ;
89374
89375   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89376   argp2 = (Dali::Actor *)jarg2;
89377   if (!argp2) {
89378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89379     return ;
89380   }
89381   arg2 = *argp2;
89382   {
89383     try {
89384       (arg1)->Remove(arg2);
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89400       };
89401     }
89402   }
89403
89404 }
89405
89406
89407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89408   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89409
89410   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89411   {
89412     try {
89413       (arg1)->Activate();
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (Dali::DaliException e) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89425       };
89426     } catch (...) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89429       };
89430     }
89431   }
89432
89433 }
89434
89435
89436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89437   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89438
89439   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89440   {
89441     try {
89442       (arg1)->ActivateOnce();
89443     } catch (std::out_of_range& e) {
89444       {
89445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89446       };
89447     } catch (std::exception& e) {
89448       {
89449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89450       };
89451     } catch (Dali::DaliException e) {
89452       {
89453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89454       };
89455     } catch (...) {
89456       {
89457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89458       };
89459     }
89460   }
89461
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89466   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89467
89468   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89469   {
89470     try {
89471       (arg1)->Deactivate();
89472     } catch (std::out_of_range& e) {
89473       {
89474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (std::exception& e) {
89477       {
89478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (Dali::DaliException e) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89483       };
89484     } catch (...) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89487       };
89488     }
89489   }
89490
89491 }
89492
89493
89494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89495   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89496   Dali::Image arg2 ;
89497   Dali::FrameBufferImage arg3 ;
89498   Dali::Image *argp2 ;
89499   Dali::FrameBufferImage *argp3 ;
89500
89501   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89502   argp2 = (Dali::Image *)jarg2;
89503   if (!argp2) {
89504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89505     return ;
89506   }
89507   arg2 = *argp2;
89508   argp3 = (Dali::FrameBufferImage *)jarg3;
89509   if (!argp3) {
89510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89511     return ;
89512   }
89513   arg3 = *argp3;
89514   {
89515     try {
89516       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89517     } catch (std::out_of_range& e) {
89518       {
89519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89520       };
89521     } catch (std::exception& e) {
89522       {
89523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89524       };
89525     } catch (Dali::DaliException e) {
89526       {
89527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89528       };
89529     } catch (...) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89532       };
89533     }
89534   }
89535
89536 }
89537
89538
89539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89540   int jresult ;
89541   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89542   Dali::Property::Index result;
89543
89544   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89545   {
89546     try {
89547       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89548     } catch (std::out_of_range& e) {
89549       {
89550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (std::exception& e) {
89553       {
89554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89555       };
89556     } catch (Dali::DaliException e) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89559       };
89560     } catch (...) {
89561       {
89562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89563       };
89564     }
89565   }
89566
89567   jresult = result;
89568   return jresult;
89569 }
89570
89571
89572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89573   void * jresult ;
89574   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89575   Dali::FrameBufferImage result;
89576
89577   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89578   {
89579     try {
89580       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89581     } catch (std::out_of_range& e) {
89582       {
89583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (std::exception& e) {
89586       {
89587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (Dali::DaliException e) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89592       };
89593     } catch (...) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89596       };
89597     }
89598   }
89599
89600   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89606   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89607   Dali::Vector4 *arg2 = 0 ;
89608
89609   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89610   arg2 = (Dali::Vector4 *)jarg2;
89611   if (!arg2) {
89612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89613     return ;
89614   }
89615   {
89616     try {
89617       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89618     } catch (std::out_of_range& e) {
89619       {
89620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (std::exception& e) {
89623       {
89624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89625       };
89626     } catch (Dali::DaliException e) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89629       };
89630     } catch (...) {
89631       {
89632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89633       };
89634     }
89635   }
89636
89637 }
89638
89639
89640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89641   void * jresult ;
89642   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89643   Dali::Vector4 result;
89644
89645   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89646   {
89647     try {
89648       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89649     } catch (std::out_of_range& e) {
89650       {
89651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89652       };
89653     } catch (std::exception& e) {
89654       {
89655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89656       };
89657     } catch (Dali::DaliException e) {
89658       {
89659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89660       };
89661     } catch (...) {
89662       {
89663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89664       };
89665     }
89666   }
89667
89668   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89669   return jresult;
89670 }
89671
89672
89673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89674   void * jresult ;
89675   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89676   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89677
89678   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89679   {
89680     try {
89681       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89682     } catch (std::out_of_range& e) {
89683       {
89684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89685       };
89686     } catch (std::exception& e) {
89687       {
89688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89689       };
89690     } catch (Dali::DaliException e) {
89691       {
89692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89693       };
89694     } catch (...) {
89695       {
89696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89697       };
89698     }
89699   }
89700
89701   jresult = (void *)result;
89702   return jresult;
89703 }
89704
89705
89706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89707   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89708
89709   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89710   {
89711     try {
89712       delete arg1;
89713     } catch (std::out_of_range& e) {
89714       {
89715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89716       };
89717     } catch (std::exception& e) {
89718       {
89719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89720       };
89721     } catch (Dali::DaliException e) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89724       };
89725     } catch (...) {
89726       {
89727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89728       };
89729     }
89730   }
89731
89732 }
89733
89734
89735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89736   unsigned int jresult ;
89737   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89738   unsigned int result;
89739
89740   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89741   {
89742     try {
89743       result = (unsigned int)(arg1)->GetNumberOfPages();
89744     } catch (std::out_of_range& e) {
89745       {
89746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89747       };
89748     } catch (std::exception& e) {
89749       {
89750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89751       };
89752     } catch (Dali::DaliException e) {
89753       {
89754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89755       };
89756     } catch (...) {
89757       {
89758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89759       };
89760     }
89761   }
89762
89763   jresult = result;
89764   return jresult;
89765 }
89766
89767
89768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89769   void * jresult ;
89770   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89771   unsigned int arg2 ;
89772   Dali::Texture result;
89773
89774   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89775   arg2 = (unsigned int)jarg2;
89776   {
89777     try {
89778       result = (arg1)->NewPage(arg2);
89779     } catch (std::out_of_range& e) {
89780       {
89781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89782       };
89783     } catch (std::exception& e) {
89784       {
89785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89786       };
89787     } catch (Dali::DaliException e) {
89788       {
89789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89790       };
89791     } catch (...) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89794       };
89795     }
89796   }
89797
89798   jresult = new Dali::Texture((const Dali::Texture &)result);
89799   return jresult;
89800 }
89801
89802
89803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89804   int jresult ;
89805   int result;
89806
89807   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89808   jresult = (int)result;
89809   return jresult;
89810 }
89811
89812
89813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89814   int jresult ;
89815   int result;
89816
89817   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89818   jresult = (int)result;
89819   return jresult;
89820 }
89821
89822
89823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89824   int jresult ;
89825   int result;
89826
89827   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89828   jresult = (int)result;
89829   return jresult;
89830 }
89831
89832
89833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89834   void * jresult ;
89835   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89836
89837   {
89838     try {
89839       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89840     } catch (std::out_of_range& e) {
89841       {
89842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89843       };
89844     } catch (std::exception& e) {
89845       {
89846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (Dali::DaliException e) {
89849       {
89850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89851       };
89852     } catch (...) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89855       };
89856     }
89857   }
89858
89859   jresult = (void *)result;
89860   return jresult;
89861 }
89862
89863
89864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89865   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89866
89867   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89868   {
89869     try {
89870       delete arg1;
89871     } catch (std::out_of_range& e) {
89872       {
89873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89874       };
89875     } catch (std::exception& e) {
89876       {
89877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (Dali::DaliException e) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89882       };
89883     } catch (...) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89886       };
89887     }
89888   }
89889
89890 }
89891
89892
89893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89894   void * jresult ;
89895   Dali::Toolkit::PageTurnView *result = 0 ;
89896
89897   {
89898     try {
89899       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89900     } catch (std::out_of_range& e) {
89901       {
89902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89903       };
89904     } catch (std::exception& e) {
89905       {
89906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89907       };
89908     } catch (Dali::DaliException e) {
89909       {
89910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89911       };
89912     } catch (...) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89915       };
89916     }
89917   }
89918
89919   jresult = (void *)result;
89920   return jresult;
89921 }
89922
89923
89924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89925   void * jresult ;
89926   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89927   Dali::Toolkit::PageTurnView *result = 0 ;
89928
89929   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89930   if (!arg1) {
89931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89932     return 0;
89933   }
89934   {
89935     try {
89936       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89937     } catch (std::out_of_range& e) {
89938       {
89939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89940       };
89941     } catch (std::exception& e) {
89942       {
89943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89944       };
89945     } catch (Dali::DaliException e) {
89946       {
89947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89948       };
89949     } catch (...) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89952       };
89953     }
89954   }
89955
89956   jresult = (void *)result;
89957   return jresult;
89958 }
89959
89960
89961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89962   void * jresult ;
89963   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89964   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89965   Dali::Toolkit::PageTurnView *result = 0 ;
89966
89967   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89968   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89969   if (!arg2) {
89970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89971     return 0;
89972   }
89973   {
89974     try {
89975       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89976     } catch (std::out_of_range& e) {
89977       {
89978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89979       };
89980     } catch (std::exception& e) {
89981       {
89982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89983       };
89984     } catch (Dali::DaliException e) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89987       };
89988     } catch (...) {
89989       {
89990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89991       };
89992     }
89993   }
89994
89995   jresult = (void *)result;
89996   return jresult;
89997 }
89998
89999
90000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90001   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90002
90003   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90004   {
90005     try {
90006       delete arg1;
90007     } catch (std::out_of_range& e) {
90008       {
90009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (std::exception& e) {
90012       {
90013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (Dali::DaliException e) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90018       };
90019     } catch (...) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90022       };
90023     }
90024   }
90025
90026 }
90027
90028
90029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90030   void * jresult ;
90031   Dali::BaseHandle arg1 ;
90032   Dali::BaseHandle *argp1 ;
90033   Dali::Toolkit::PageTurnView result;
90034
90035   argp1 = (Dali::BaseHandle *)jarg1;
90036   if (!argp1) {
90037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90038     return 0;
90039   }
90040   arg1 = *argp1;
90041   {
90042     try {
90043       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90044     } catch (std::out_of_range& e) {
90045       {
90046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90047       };
90048     } catch (std::exception& e) {
90049       {
90050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (Dali::DaliException e) {
90053       {
90054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90059       };
90060     }
90061   }
90062
90063   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90064   return jresult;
90065 }
90066
90067
90068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90069   void * jresult ;
90070   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90071   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90072
90073   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90074   {
90075     try {
90076       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90077     } catch (std::out_of_range& e) {
90078       {
90079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90080       };
90081     } catch (std::exception& e) {
90082       {
90083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (Dali::DaliException e) {
90086       {
90087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90088       };
90089     } catch (...) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90092       };
90093     }
90094   }
90095
90096   jresult = (void *)result;
90097   return jresult;
90098 }
90099
90100
90101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90102   void * jresult ;
90103   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90104   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90105
90106   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90107   {
90108     try {
90109       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90110     } catch (std::out_of_range& e) {
90111       {
90112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90113       };
90114     } catch (std::exception& e) {
90115       {
90116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (Dali::DaliException e) {
90119       {
90120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90121       };
90122     } catch (...) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90125       };
90126     }
90127   }
90128
90129   jresult = (void *)result;
90130   return jresult;
90131 }
90132
90133
90134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90135   void * jresult ;
90136   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90137   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90138
90139   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90140   {
90141     try {
90142       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90143     } catch (std::out_of_range& e) {
90144       {
90145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90146       };
90147     } catch (std::exception& e) {
90148       {
90149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (Dali::DaliException e) {
90152       {
90153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90154       };
90155     } catch (...) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90158       };
90159     }
90160   }
90161
90162   jresult = (void *)result;
90163   return jresult;
90164 }
90165
90166
90167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90168   void * jresult ;
90169   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90170   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90171
90172   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90173   {
90174     try {
90175       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90176     } catch (std::out_of_range& e) {
90177       {
90178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (std::exception& e) {
90181       {
90182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90183       };
90184     } catch (Dali::DaliException e) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90187       };
90188     } catch (...) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90191       };
90192     }
90193   }
90194
90195   jresult = (void *)result;
90196   return jresult;
90197 }
90198
90199
90200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90201   void * jresult ;
90202   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90203
90204   {
90205     try {
90206       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90207     } catch (std::out_of_range& e) {
90208       {
90209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90210       };
90211     } catch (std::exception& e) {
90212       {
90213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90214       };
90215     } catch (Dali::DaliException e) {
90216       {
90217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90218       };
90219     } catch (...) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90222       };
90223     }
90224   }
90225
90226   jresult = (void *)result;
90227   return jresult;
90228 }
90229
90230
90231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90232   void * jresult ;
90233   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90234   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90235
90236   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90237   if (!arg1) {
90238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90239     return 0;
90240   }
90241   {
90242     try {
90243       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90244     } catch (std::out_of_range& e) {
90245       {
90246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90247       };
90248     } catch (std::exception& e) {
90249       {
90250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90251       };
90252     } catch (Dali::DaliException e) {
90253       {
90254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90255       };
90256     } catch (...) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90259       };
90260     }
90261   }
90262
90263   jresult = (void *)result;
90264   return jresult;
90265 }
90266
90267
90268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90269   void * jresult ;
90270   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90271   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90272   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90273
90274   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90275   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90276   if (!arg2) {
90277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90278     return 0;
90279   }
90280   {
90281     try {
90282       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90283     } catch (std::out_of_range& e) {
90284       {
90285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90286       };
90287     } catch (std::exception& e) {
90288       {
90289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90290       };
90291     } catch (Dali::DaliException e) {
90292       {
90293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90294       };
90295     } catch (...) {
90296       {
90297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90298       };
90299     }
90300   }
90301
90302   jresult = (void *)result;
90303   return jresult;
90304 }
90305
90306
90307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90308   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90309
90310   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90311   {
90312     try {
90313       delete arg1;
90314     } catch (std::out_of_range& e) {
90315       {
90316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90317       };
90318     } catch (std::exception& e) {
90319       {
90320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90321       };
90322     } catch (Dali::DaliException e) {
90323       {
90324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90325       };
90326     } catch (...) {
90327       {
90328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90329       };
90330     }
90331   }
90332
90333 }
90334
90335
90336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90337   void * jresult ;
90338   Dali::Toolkit::PageFactory *arg1 = 0 ;
90339   Dali::Vector2 *arg2 = 0 ;
90340   Dali::Toolkit::PageTurnLandscapeView result;
90341
90342   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90343   if (!arg1) {
90344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90345     return 0;
90346   }
90347   arg2 = (Dali::Vector2 *)jarg2;
90348   if (!arg2) {
90349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90350     return 0;
90351   }
90352   {
90353     try {
90354       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90355     } catch (std::out_of_range& e) {
90356       {
90357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90358       };
90359     } catch (std::exception& e) {
90360       {
90361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (Dali::DaliException e) {
90364       {
90365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90366       };
90367     } catch (...) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90370       };
90371     }
90372   }
90373
90374   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90375   return jresult;
90376 }
90377
90378
90379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90380   void * jresult ;
90381   Dali::BaseHandle arg1 ;
90382   Dali::BaseHandle *argp1 ;
90383   Dali::Toolkit::PageTurnLandscapeView result;
90384
90385   argp1 = (Dali::BaseHandle *)jarg1;
90386   if (!argp1) {
90387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90388     return 0;
90389   }
90390   arg1 = *argp1;
90391   {
90392     try {
90393       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90394     } catch (std::out_of_range& e) {
90395       {
90396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (std::exception& e) {
90399       {
90400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (Dali::DaliException e) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90405       };
90406     } catch (...) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90409       };
90410     }
90411   }
90412
90413   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90414   return jresult;
90415 }
90416
90417
90418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90419   void * jresult ;
90420   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90421
90422   {
90423     try {
90424       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90425     } catch (std::out_of_range& e) {
90426       {
90427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90428       };
90429     } catch (std::exception& e) {
90430       {
90431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90432       };
90433     } catch (Dali::DaliException e) {
90434       {
90435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90436       };
90437     } catch (...) {
90438       {
90439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90440       };
90441     }
90442   }
90443
90444   jresult = (void *)result;
90445   return jresult;
90446 }
90447
90448
90449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90450   void * jresult ;
90451   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90452   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90453
90454   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90455   if (!arg1) {
90456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90457     return 0;
90458   }
90459   {
90460     try {
90461       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (Dali::DaliException e) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90473       };
90474     } catch (...) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90477       };
90478     }
90479   }
90480
90481   jresult = (void *)result;
90482   return jresult;
90483 }
90484
90485
90486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90487   void * jresult ;
90488   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90489   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90490   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90491
90492   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90493   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90494   if (!arg2) {
90495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90496     return 0;
90497   }
90498   {
90499     try {
90500       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90501     } catch (std::out_of_range& e) {
90502       {
90503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90504       };
90505     } catch (std::exception& e) {
90506       {
90507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90508       };
90509     } catch (Dali::DaliException e) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90512       };
90513     } catch (...) {
90514       {
90515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90516       };
90517     }
90518   }
90519
90520   jresult = (void *)result;
90521   return jresult;
90522 }
90523
90524
90525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90526   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90527
90528   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90529   {
90530     try {
90531       delete arg1;
90532     } catch (std::out_of_range& e) {
90533       {
90534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90535       };
90536     } catch (std::exception& e) {
90537       {
90538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90539       };
90540     } catch (Dali::DaliException e) {
90541       {
90542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90543       };
90544     } catch (...) {
90545       {
90546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90547       };
90548     }
90549   }
90550
90551 }
90552
90553
90554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90555   void * jresult ;
90556   Dali::Toolkit::PageFactory *arg1 = 0 ;
90557   Dali::Vector2 *arg2 = 0 ;
90558   Dali::Toolkit::PageTurnPortraitView result;
90559
90560   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90561   if (!arg1) {
90562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90563     return 0;
90564   }
90565   arg2 = (Dali::Vector2 *)jarg2;
90566   if (!arg2) {
90567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90568     return 0;
90569   }
90570   {
90571     try {
90572       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90573     } catch (std::out_of_range& e) {
90574       {
90575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90576       };
90577     } catch (std::exception& e) {
90578       {
90579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (Dali::DaliException e) {
90582       {
90583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90584       };
90585     } catch (...) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90588       };
90589     }
90590   }
90591
90592   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90593   return jresult;
90594 }
90595
90596
90597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90598   void * jresult ;
90599   Dali::BaseHandle arg1 ;
90600   Dali::BaseHandle *argp1 ;
90601   Dali::Toolkit::PageTurnPortraitView result;
90602
90603   argp1 = (Dali::BaseHandle *)jarg1;
90604   if (!argp1) {
90605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90606     return 0;
90607   }
90608   arg1 = *argp1;
90609   {
90610     try {
90611       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90612     } catch (std::out_of_range& e) {
90613       {
90614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90615       };
90616     } catch (std::exception& e) {
90617       {
90618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (Dali::DaliException e) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90623       };
90624     } catch (...) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90627       };
90628     }
90629   }
90630
90631   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90632   return jresult;
90633 }
90634
90635
90636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90637   int jresult ;
90638   int result;
90639
90640   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90641   jresult = (int)result;
90642   return jresult;
90643 }
90644
90645
90646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90647   int jresult ;
90648   int result;
90649
90650   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90651   jresult = (int)result;
90652   return jresult;
90653 }
90654
90655
90656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90657   int jresult ;
90658   int result;
90659
90660   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90661   jresult = (int)result;
90662   return jresult;
90663 }
90664
90665
90666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90667   void * jresult ;
90668   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90669
90670   {
90671     try {
90672       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90673     } catch (std::out_of_range& e) {
90674       {
90675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90676       };
90677     } catch (std::exception& e) {
90678       {
90679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (Dali::DaliException e) {
90682       {
90683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90684       };
90685     } catch (...) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90688       };
90689     }
90690   }
90691
90692   jresult = (void *)result;
90693   return jresult;
90694 }
90695
90696
90697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90698   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90699
90700   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90701   {
90702     try {
90703       delete arg1;
90704     } catch (std::out_of_range& e) {
90705       {
90706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90707       };
90708     } catch (std::exception& e) {
90709       {
90710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90711       };
90712     } catch (Dali::DaliException e) {
90713       {
90714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90715       };
90716     } catch (...) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90719       };
90720     }
90721   }
90722
90723 }
90724
90725
90726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90727   void * jresult ;
90728   Dali::Toolkit::ToggleButton *result = 0 ;
90729
90730   {
90731     try {
90732       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90733     } catch (std::out_of_range& e) {
90734       {
90735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (std::exception& e) {
90738       {
90739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90740       };
90741     } catch (Dali::DaliException e) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90744       };
90745     } catch (...) {
90746       {
90747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90748       };
90749     }
90750   }
90751
90752   jresult = (void *)result;
90753   return jresult;
90754 }
90755
90756
90757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90758   void * jresult ;
90759   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90760   Dali::Toolkit::ToggleButton *result = 0 ;
90761
90762   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90763   if (!arg1) {
90764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90765     return 0;
90766   }
90767   {
90768     try {
90769       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90770     } catch (std::out_of_range& e) {
90771       {
90772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90773       };
90774     } catch (std::exception& e) {
90775       {
90776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90777       };
90778     } catch (Dali::DaliException e) {
90779       {
90780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90781       };
90782     } catch (...) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90785       };
90786     }
90787   }
90788
90789   jresult = (void *)result;
90790   return jresult;
90791 }
90792
90793
90794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90795   void * jresult ;
90796   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90797   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90798   Dali::Toolkit::ToggleButton *result = 0 ;
90799
90800   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90801   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90802   if (!arg2) {
90803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90804     return 0;
90805   }
90806   {
90807     try {
90808       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90809     } catch (std::out_of_range& e) {
90810       {
90811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90812       };
90813     } catch (std::exception& e) {
90814       {
90815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (Dali::DaliException e) {
90818       {
90819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90820       };
90821     } catch (...) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90824       };
90825     }
90826   }
90827
90828   jresult = (void *)result;
90829   return jresult;
90830 }
90831
90832
90833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90834   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90835
90836   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90837   {
90838     try {
90839       delete arg1;
90840     } catch (std::out_of_range& e) {
90841       {
90842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90843       };
90844     } catch (std::exception& e) {
90845       {
90846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (Dali::DaliException e) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90851       };
90852     } catch (...) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90855       };
90856     }
90857   }
90858
90859 }
90860
90861
90862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90863   void * jresult ;
90864   Dali::Toolkit::ToggleButton result;
90865
90866   {
90867     try {
90868       result = Dali::Toolkit::ToggleButton::New();
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (Dali::DaliException e) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90884       };
90885     }
90886   }
90887
90888   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90889   return jresult;
90890 }
90891
90892
90893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90894   void * jresult ;
90895   Dali::BaseHandle arg1 ;
90896   Dali::BaseHandle *argp1 ;
90897   Dali::Toolkit::ToggleButton result;
90898
90899   argp1 = (Dali::BaseHandle *)jarg1;
90900   if (!argp1) {
90901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90902     return 0;
90903   }
90904   arg1 = *argp1;
90905   {
90906     try {
90907       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (Dali::DaliException e) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90923       };
90924     }
90925   }
90926
90927   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90928   return jresult;
90929 }
90930
90931
90932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90933   void * jresult ;
90934   Dali::Toolkit::Visual::Base *result = 0 ;
90935
90936   {
90937     try {
90938       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90939     } catch (std::out_of_range& e) {
90940       {
90941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90942       };
90943     } catch (std::exception& e) {
90944       {
90945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90946       };
90947     } catch (Dali::DaliException e) {
90948       {
90949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90950       };
90951     } catch (...) {
90952       {
90953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90954       };
90955     }
90956   }
90957
90958   jresult = (void *)result;
90959   return jresult;
90960 }
90961
90962
90963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90964   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90965
90966   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90967   {
90968     try {
90969       delete arg1;
90970     } catch (std::out_of_range& e) {
90971       {
90972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90973       };
90974     } catch (std::exception& e) {
90975       {
90976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (Dali::DaliException e) {
90979       {
90980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90981       };
90982     } catch (...) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90985       };
90986     }
90987   }
90988
90989 }
90990
90991
90992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90993   void * jresult ;
90994   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90995   Dali::Toolkit::Visual::Base *result = 0 ;
90996
90997   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90998   if (!arg1) {
90999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91000     return 0;
91001   }
91002   {
91003     try {
91004       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91005     } catch (std::out_of_range& e) {
91006       {
91007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91008       };
91009     } catch (std::exception& e) {
91010       {
91011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91012       };
91013     } catch (Dali::DaliException e) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91020       };
91021     }
91022   }
91023
91024   jresult = (void *)result;
91025   return jresult;
91026 }
91027
91028
91029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91030   void * jresult ;
91031   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91032   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91033   Dali::Toolkit::Visual::Base *result = 0 ;
91034
91035   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91036   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91037   if (!arg2) {
91038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91039     return 0;
91040   }
91041   {
91042     try {
91043       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91044     } catch (std::out_of_range& e) {
91045       {
91046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91047       };
91048     } catch (std::exception& e) {
91049       {
91050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91051       };
91052     } catch (Dali::DaliException e) {
91053       {
91054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91055       };
91056     } catch (...) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91059       };
91060     }
91061   }
91062
91063   jresult = (void *)result;
91064   return jresult;
91065 }
91066
91067
91068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91069   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91070   std::string *arg2 = 0 ;
91071
91072   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91073   if (!jarg2) {
91074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91075     return ;
91076   }
91077   std::string arg2_str(jarg2);
91078   arg2 = &arg2_str;
91079   {
91080     try {
91081       (arg1)->SetName((std::string const &)*arg2);
91082     } catch (std::out_of_range& e) {
91083       {
91084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91085       };
91086     } catch (std::exception& e) {
91087       {
91088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91089       };
91090     } catch (Dali::DaliException e) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91093       };
91094     } catch (...) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91097       };
91098     }
91099   }
91100
91101
91102   //argout typemap for const std::string&
91103
91104 }
91105
91106
91107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91108   char * jresult ;
91109   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91110   std::string *result = 0 ;
91111
91112   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91113   {
91114     try {
91115       result = (std::string *) &(arg1)->GetName();
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (Dali::DaliException e) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91127       };
91128     } catch (...) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91131       };
91132     }
91133   }
91134
91135   jresult = SWIG_csharp_string_callback(result->c_str());
91136   return jresult;
91137 }
91138
91139
91140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91141   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91142   Dali::Property::Map *arg2 = 0 ;
91143   Dali::Size arg3 ;
91144   Dali::Size *argp3 ;
91145
91146   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91147   arg2 = (Dali::Property::Map *)jarg2;
91148   if (!arg2) {
91149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91150     return ;
91151   }
91152   argp3 = (Dali::Size *)jarg3;
91153   if (!argp3) {
91154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91155     return ;
91156   }
91157   arg3 = *argp3;
91158   {
91159     try {
91160       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91161     } catch (std::out_of_range& e) {
91162       {
91163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91164       };
91165     } catch (std::exception& e) {
91166       {
91167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91168       };
91169     } catch (Dali::DaliException e) {
91170       {
91171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91172       };
91173     } catch (...) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91176       };
91177     }
91178   }
91179
91180 }
91181
91182
91183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91184   float jresult ;
91185   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91186   float arg2 ;
91187   float result;
91188
91189   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91190   arg2 = (float)jarg2;
91191   {
91192     try {
91193       result = (float)(arg1)->GetHeightForWidth(arg2);
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (Dali::DaliException e) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91209       };
91210     }
91211   }
91212
91213   jresult = result;
91214   return jresult;
91215 }
91216
91217
91218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91219   float jresult ;
91220   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91221   float arg2 ;
91222   float result;
91223
91224   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91225   arg2 = (float)jarg2;
91226   {
91227     try {
91228       result = (float)(arg1)->GetWidthForHeight(arg2);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (Dali::DaliException e) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91240       };
91241     } catch (...) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91244       };
91245     }
91246   }
91247
91248   jresult = result;
91249   return jresult;
91250 }
91251
91252
91253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91254   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91255   Dali::Vector2 *arg2 = 0 ;
91256
91257   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91258   arg2 = (Dali::Vector2 *)jarg2;
91259   if (!arg2) {
91260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91261     return ;
91262   }
91263   {
91264     try {
91265       (arg1)->GetNaturalSize(*arg2);
91266     } catch (std::out_of_range& e) {
91267       {
91268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91269       };
91270     } catch (std::exception& e) {
91271       {
91272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91273       };
91274     } catch (Dali::DaliException e) {
91275       {
91276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91277       };
91278     } catch (...) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91281       };
91282     }
91283   }
91284
91285 }
91286
91287
91288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91289   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91290   float arg2 ;
91291
91292   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91293   arg2 = (int)jarg2;
91294   {
91295     try {
91296       (arg1)->SetDepthIndex(arg2);
91297     } catch (std::out_of_range& e) {
91298       {
91299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91300       };
91301     } catch (std::exception& e) {
91302       {
91303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91304       };
91305     } catch (Dali::DaliException e) {
91306       {
91307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91308       };
91309     } catch (...) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91312       };
91313     }
91314   }
91315
91316 }
91317
91318
91319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91320   int jresult ;
91321   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91322   int result;
91323
91324   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91325   {
91326     try {
91327       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91328     } catch (std::out_of_range& e) {
91329       {
91330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91331       };
91332     } catch (std::exception& e) {
91333       {
91334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (Dali::DaliException e) {
91337       {
91338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91339       };
91340     } catch (...) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91343       };
91344     }
91345   }
91346
91347   jresult = result;
91348   return jresult;
91349 }
91350
91351
91352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91353   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91354   Dali::Property::Map *arg2 = 0 ;
91355
91356   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91357   arg2 = (Dali::Property::Map *)jarg2;
91358   if (!arg2) {
91359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91360     return ;
91361   }
91362   {
91363     try {
91364       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (Dali::DaliException e) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91380       };
91381     }
91382   }
91383
91384 }
91385
91386
91387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91388   void * jresult ;
91389   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91390   Dali::Toolkit::Visual::Base *result = 0 ;
91391
91392   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91393   {
91394     try {
91395       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91396     } catch (std::out_of_range& e) {
91397       {
91398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91399       };
91400     } catch (std::exception& e) {
91401       {
91402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91403       };
91404     } catch (Dali::DaliException e) {
91405       {
91406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91407       };
91408     } catch (...) {
91409       {
91410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91411       };
91412     }
91413   }
91414
91415   jresult = (void *)result;
91416   return jresult;
91417 }
91418
91419
91420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91421   void * jresult ;
91422   Dali::Toolkit::VisualFactory result;
91423
91424   {
91425     try {
91426       result = Dali::Toolkit::VisualFactory::Get();
91427     } catch (std::out_of_range& e) {
91428       {
91429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91430       };
91431     } catch (std::exception& e) {
91432       {
91433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91434       };
91435     } catch (Dali::DaliException e) {
91436       {
91437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91438       };
91439     } catch (...) {
91440       {
91441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91442       };
91443     }
91444   }
91445
91446   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91447   return jresult;
91448 }
91449
91450
91451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91452   void * jresult ;
91453   Dali::Toolkit::VisualFactory *result = 0 ;
91454
91455   {
91456     try {
91457       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91458     } catch (std::out_of_range& e) {
91459       {
91460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91461       };
91462     } catch (std::exception& e) {
91463       {
91464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91465       };
91466     } catch (Dali::DaliException e) {
91467       {
91468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91469       };
91470     } catch (...) {
91471       {
91472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91473       };
91474     }
91475   }
91476
91477   jresult = (void *)result;
91478   return jresult;
91479 }
91480
91481
91482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91483   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91484
91485   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91486   {
91487     try {
91488       delete arg1;
91489     } catch (std::out_of_range& e) {
91490       {
91491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91492       };
91493     } catch (std::exception& e) {
91494       {
91495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91496       };
91497     } catch (Dali::DaliException e) {
91498       {
91499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91500       };
91501     } catch (...) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91504       };
91505     }
91506   }
91507
91508 }
91509
91510
91511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91512   void * jresult ;
91513   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91514   Dali::Toolkit::VisualFactory *result = 0 ;
91515
91516   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91517   if (!arg1) {
91518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91519     return 0;
91520   }
91521   {
91522     try {
91523       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91524     } catch (std::out_of_range& e) {
91525       {
91526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91527       };
91528     } catch (std::exception& e) {
91529       {
91530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91531       };
91532     } catch (Dali::DaliException e) {
91533       {
91534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91535       };
91536     } catch (...) {
91537       {
91538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91539       };
91540     }
91541   }
91542
91543   jresult = (void *)result;
91544   return jresult;
91545 }
91546
91547
91548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91549   void * jresult ;
91550   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91551   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91552   Dali::Toolkit::VisualFactory *result = 0 ;
91553
91554   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91555   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91556   if (!arg2) {
91557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91558     return 0;
91559   }
91560   {
91561     try {
91562       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91563     } catch (std::out_of_range& e) {
91564       {
91565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91566       };
91567     } catch (std::exception& e) {
91568       {
91569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91570       };
91571     } catch (Dali::DaliException e) {
91572       {
91573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91574       };
91575     } catch (...) {
91576       {
91577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91578       };
91579     }
91580   }
91581
91582   jresult = (void *)result;
91583   return jresult;
91584 }
91585
91586
91587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91588   void * jresult ;
91589   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91590   Dali::Property::Map *arg2 = 0 ;
91591   Dali::Toolkit::Visual::Base result;
91592
91593   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91594   arg2 = (Dali::Property::Map *)jarg2;
91595   if (!arg2) {
91596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91597     return 0;
91598   }
91599   {
91600     try {
91601       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91602     } catch (std::out_of_range& e) {
91603       {
91604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91605       };
91606     } catch (std::exception& e) {
91607       {
91608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (Dali::DaliException e) {
91611       {
91612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91613       };
91614     } catch (...) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91617       };
91618     }
91619   }
91620
91621   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91622   return jresult;
91623 }
91624
91625
91626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91627   void * jresult ;
91628   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91629   Dali::Image *arg2 = 0 ;
91630   Dali::Toolkit::Visual::Base result;
91631
91632   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91633   arg2 = (Dali::Image *)jarg2;
91634   if (!arg2) {
91635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91636     return 0;
91637   }
91638   {
91639     try {
91640       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91641     } catch (std::out_of_range& e) {
91642       {
91643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91644       };
91645     } catch (std::exception& e) {
91646       {
91647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91648       };
91649     } catch (Dali::DaliException e) {
91650       {
91651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91652       };
91653     } catch (...) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91656       };
91657     }
91658   }
91659
91660   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91661   return jresult;
91662 }
91663
91664
91665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91666   void * jresult ;
91667   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91668   std::string *arg2 = 0 ;
91669   Dali::ImageDimensions arg3 ;
91670   Dali::ImageDimensions *argp3 ;
91671   Dali::Toolkit::Visual::Base result;
91672
91673   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91674   if (!jarg2) {
91675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91676     return 0;
91677   }
91678   std::string arg2_str(jarg2);
91679   arg2 = &arg2_str;
91680   argp3 = (Dali::ImageDimensions *)jarg3;
91681   if (!argp3) {
91682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91683     return 0;
91684   }
91685   arg3 = *argp3;
91686   {
91687     try {
91688       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91689     } catch (std::out_of_range& e) {
91690       {
91691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91692       };
91693     } catch (std::exception& e) {
91694       {
91695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91696       };
91697     } catch (Dali::DaliException e) {
91698       {
91699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91700       };
91701     } catch (...) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91704       };
91705     }
91706   }
91707
91708   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91709
91710   //argout typemap for const std::string&
91711
91712   return jresult;
91713 }
91714
91715
91716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91717   void * jresult ;
91718   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91719
91720   {
91721     try {
91722       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91723     } catch (std::out_of_range& e) {
91724       {
91725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91726       };
91727     } catch (std::exception& e) {
91728       {
91729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91730       };
91731     } catch (Dali::DaliException e) {
91732       {
91733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91734       };
91735     } catch (...) {
91736       {
91737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91738       };
91739     }
91740   }
91741
91742   jresult = (void *)result;
91743   return jresult;
91744 }
91745
91746
91747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91748   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91749
91750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91751   {
91752     try {
91753       delete arg1;
91754     } catch (std::out_of_range& e) {
91755       {
91756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91757       };
91758     } catch (std::exception& e) {
91759       {
91760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91761       };
91762     } catch (Dali::DaliException e) {
91763       {
91764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91765       };
91766     } catch (...) {
91767       {
91768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91769       };
91770     }
91771   }
91772
91773 }
91774
91775
91776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91777   void * jresult ;
91778   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91779   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91780
91781   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91782   if (!arg1) {
91783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91784     return 0;
91785   }
91786   {
91787     try {
91788       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91789     } catch (std::out_of_range& e) {
91790       {
91791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91792       };
91793     } catch (std::exception& e) {
91794       {
91795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91796       };
91797     } catch (Dali::DaliException e) {
91798       {
91799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91800       };
91801     } catch (...) {
91802       {
91803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91804       };
91805     }
91806   }
91807
91808   jresult = (void *)result;
91809   return jresult;
91810 }
91811
91812
91813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91814   void * jresult ;
91815   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91816   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91817   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91818
91819   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91820   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91821   if (!arg2) {
91822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91823     return 0;
91824   }
91825   {
91826     try {
91827       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91828     } catch (std::out_of_range& e) {
91829       {
91830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91831       };
91832     } catch (std::exception& e) {
91833       {
91834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (Dali::DaliException e) {
91837       {
91838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91843       };
91844     }
91845   }
91846
91847   jresult = (void *)result;
91848   return jresult;
91849 }
91850
91851
91852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91853   void * jresult ;
91854   Dali::Toolkit::AsyncImageLoader result;
91855
91856   {
91857     try {
91858       result = Dali::Toolkit::AsyncImageLoader::New();
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91874       };
91875     }
91876   }
91877
91878   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91879   return jresult;
91880 }
91881
91882
91883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91884   void * jresult ;
91885   Dali::BaseHandle arg1 ;
91886   Dali::BaseHandle *argp1 ;
91887   Dali::Toolkit::AsyncImageLoader result;
91888
91889   argp1 = (Dali::BaseHandle *)jarg1;
91890   if (!argp1) {
91891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91892     return 0;
91893   }
91894   arg1 = *argp1;
91895   {
91896     try {
91897       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91898     } catch (std::out_of_range& e) {
91899       {
91900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91901       };
91902     } catch (std::exception& e) {
91903       {
91904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91905       };
91906     } catch (Dali::DaliException e) {
91907       {
91908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91909       };
91910     } catch (...) {
91911       {
91912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91913       };
91914     }
91915   }
91916
91917   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91918   return jresult;
91919 }
91920
91921
91922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91923   unsigned int jresult ;
91924   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91925   std::string *arg2 = 0 ;
91926   uint32_t result;
91927
91928   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91929   if (!jarg2) {
91930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91931     return 0;
91932   }
91933   std::string arg2_str(jarg2);
91934   arg2 = &arg2_str;
91935   {
91936     try {
91937       result = (arg1)->Load((std::string const &)*arg2);
91938     } catch (std::out_of_range& e) {
91939       {
91940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91941       };
91942     } catch (std::exception& e) {
91943       {
91944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91945       };
91946     } catch (Dali::DaliException e) {
91947       {
91948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91949       };
91950     } catch (...) {
91951       {
91952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91953       };
91954     }
91955   }
91956
91957   jresult = result;
91958
91959   //argout typemap for const std::string&
91960
91961   return jresult;
91962 }
91963
91964
91965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91966   unsigned int jresult ;
91967   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91968   std::string *arg2 = 0 ;
91969   Dali::ImageDimensions arg3 ;
91970   Dali::ImageDimensions *argp3 ;
91971   uint32_t result;
91972
91973   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91974   if (!jarg2) {
91975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91976     return 0;
91977   }
91978   std::string arg2_str(jarg2);
91979   arg2 = &arg2_str;
91980   argp3 = (Dali::ImageDimensions *)jarg3;
91981   if (!argp3) {
91982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91983     return 0;
91984   }
91985   arg3 = *argp3;
91986   {
91987     try {
91988       result = (arg1)->Load((std::string const &)*arg2,arg3);
91989     } catch (std::out_of_range& e) {
91990       {
91991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91992       };
91993     } catch (std::exception& e) {
91994       {
91995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91996       };
91997     } catch (Dali::DaliException e) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92000       };
92001     } catch (...) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92004       };
92005     }
92006   }
92007
92008   jresult = result;
92009
92010   //argout typemap for const std::string&
92011
92012   return jresult;
92013 }
92014
92015
92016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92017   unsigned int jresult ;
92018   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92019   std::string *arg2 = 0 ;
92020   Dali::ImageDimensions arg3 ;
92021   Dali::FittingMode::Type arg4 ;
92022   Dali::SamplingMode::Type arg5 ;
92023   bool arg6 ;
92024   Dali::ImageDimensions *argp3 ;
92025   uint32_t result;
92026
92027   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92028   if (!jarg2) {
92029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92030     return 0;
92031   }
92032   std::string arg2_str(jarg2);
92033   arg2 = &arg2_str;
92034   argp3 = (Dali::ImageDimensions *)jarg3;
92035   if (!argp3) {
92036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92037     return 0;
92038   }
92039   arg3 = *argp3;
92040   arg4 = (Dali::FittingMode::Type)jarg4;
92041   arg5 = (Dali::SamplingMode::Type)jarg5;
92042   arg6 = jarg6 ? true : false;
92043   {
92044     try {
92045       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92046     } catch (std::out_of_range& e) {
92047       {
92048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92049       };
92050     } catch (std::exception& e) {
92051       {
92052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (Dali::DaliException e) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92057       };
92058     } catch (...) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92061       };
92062     }
92063   }
92064
92065   jresult = result;
92066
92067   //argout typemap for const std::string&
92068
92069   return jresult;
92070 }
92071
92072
92073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92074   unsigned int jresult ;
92075   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92076   uint32_t arg2 ;
92077   bool result;
92078
92079   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92080   arg2 = (uint32_t)jarg2;
92081   {
92082     try {
92083       result = (bool)(arg1)->Cancel(arg2);
92084     } catch (std::out_of_range& e) {
92085       {
92086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (std::exception& e) {
92089       {
92090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (Dali::DaliException e) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92095       };
92096     } catch (...) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92099       };
92100     }
92101   }
92102
92103   jresult = result;
92104   return jresult;
92105 }
92106
92107
92108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92109   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92110
92111   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92112   {
92113     try {
92114       (arg1)->CancelAll();
92115     } catch (std::out_of_range& e) {
92116       {
92117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92118       };
92119     } catch (std::exception& e) {
92120       {
92121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92122       };
92123     } catch (Dali::DaliException e) {
92124       {
92125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92126       };
92127     } catch (...) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92130       };
92131     }
92132   }
92133
92134 }
92135
92136
92137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92138   void * jresult ;
92139   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92140   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92141
92142   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92143   {
92144     try {
92145       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92146     } catch (std::out_of_range& e) {
92147       {
92148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92149       };
92150     } catch (std::exception& e) {
92151       {
92152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92153       };
92154     } catch (Dali::DaliException e) {
92155       {
92156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92157       };
92158     } catch (...) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92161       };
92162     }
92163   }
92164
92165   jresult = (void *)result;
92166   return jresult;
92167 }
92168
92169
92170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92171   void * jresult ;
92172   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92173   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92174
92175   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92176   {
92177     try {
92178       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92179     } catch (std::out_of_range& e) {
92180       {
92181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92182       };
92183     } catch (std::exception& e) {
92184       {
92185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (Dali::DaliException e) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92190       };
92191     } catch (...) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92194       };
92195     }
92196   }
92197
92198   jresult = (void *)result;
92199   return jresult;
92200 }
92201
92202
92203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92204   void * jresult ;
92205   std::string *arg1 = 0 ;
92206   Dali::PixelData result;
92207
92208   if (!jarg1) {
92209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92210     return 0;
92211   }
92212   std::string arg1_str(jarg1);
92213   arg1 = &arg1_str;
92214   {
92215     try {
92216       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92217     } catch (std::out_of_range& e) {
92218       {
92219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (std::exception& e) {
92222       {
92223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92224       };
92225     } catch (Dali::DaliException e) {
92226       {
92227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92228       };
92229     } catch (...) {
92230       {
92231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92232       };
92233     }
92234   }
92235
92236   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92237
92238   //argout typemap for const std::string&
92239
92240   return jresult;
92241 }
92242
92243
92244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92245   void * jresult ;
92246   std::string *arg1 = 0 ;
92247   Dali::ImageDimensions arg2 ;
92248   Dali::ImageDimensions *argp2 ;
92249   Dali::PixelData result;
92250
92251   if (!jarg1) {
92252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92253     return 0;
92254   }
92255   std::string arg1_str(jarg1);
92256   arg1 = &arg1_str;
92257   argp2 = (Dali::ImageDimensions *)jarg2;
92258   if (!argp2) {
92259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92260     return 0;
92261   }
92262   arg2 = *argp2;
92263   {
92264     try {
92265       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (Dali::DaliException e) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92277       };
92278     } catch (...) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92281       };
92282     }
92283   }
92284
92285   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92286
92287   //argout typemap for const std::string&
92288
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92294   void * jresult ;
92295   std::string *arg1 = 0 ;
92296   Dali::ImageDimensions arg2 ;
92297   Dali::FittingMode::Type arg3 ;
92298   Dali::SamplingMode::Type arg4 ;
92299   bool arg5 ;
92300   Dali::ImageDimensions *argp2 ;
92301   Dali::PixelData result;
92302
92303   if (!jarg1) {
92304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92305     return 0;
92306   }
92307   std::string arg1_str(jarg1);
92308   arg1 = &arg1_str;
92309   argp2 = (Dali::ImageDimensions *)jarg2;
92310   if (!argp2) {
92311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92312     return 0;
92313   }
92314   arg2 = *argp2;
92315   arg3 = (Dali::FittingMode::Type)jarg3;
92316   arg4 = (Dali::SamplingMode::Type)jarg4;
92317   arg5 = jarg5 ? true : false;
92318   {
92319     try {
92320       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92321     } catch (std::out_of_range& e) {
92322       {
92323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92324       };
92325     } catch (std::exception& e) {
92326       {
92327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (Dali::DaliException e) {
92330       {
92331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92332       };
92333     } catch (...) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92336       };
92337     }
92338   }
92339
92340   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92341
92342   //argout typemap for const std::string&
92343
92344   return jresult;
92345 }
92346
92347
92348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92349   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92350
92351   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92352   {
92353     try {
92354       delete arg1;
92355     } catch (std::out_of_range& e) {
92356       {
92357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92358       };
92359     } catch (std::exception& e) {
92360       {
92361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92362       };
92363     } catch (Dali::DaliException e) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92366       };
92367     } catch (...) {
92368       {
92369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92370       };
92371     }
92372   }
92373
92374 }
92375
92376
92377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92378   void * jresult ;
92379   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92380   Dali::Actor arg2 ;
92381   Dali::Actor arg3 ;
92382   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92383   Dali::Actor *argp2 ;
92384   Dali::Actor *argp3 ;
92385   Dali::Actor result;
92386
92387   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92388   argp2 = (Dali::Actor *)jarg2;
92389   if (!argp2) {
92390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92391     return 0;
92392   }
92393   arg2 = *argp2;
92394   argp3 = (Dali::Actor *)jarg3;
92395   if (!argp3) {
92396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92397     return 0;
92398   }
92399   arg3 = *argp3;
92400   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92401   {
92402     try {
92403       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92404     } catch (std::out_of_range& e) {
92405       {
92406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92407       };
92408     } catch (std::exception& e) {
92409       {
92410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92411       };
92412     } catch (Dali::DaliException e) {
92413       {
92414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92415       };
92416     } catch (...) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92419       };
92420     }
92421   }
92422
92423   jresult = new Dali::Actor((const Dali::Actor &)result);
92424   return jresult;
92425 }
92426
92427
92428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92429   void * jresult ;
92430   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92431
92432   {
92433     try {
92434       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92435     } catch (std::out_of_range& e) {
92436       {
92437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92438       };
92439     } catch (std::exception& e) {
92440       {
92441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92442       };
92443     } catch (Dali::DaliException e) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92446       };
92447     } catch (...) {
92448       {
92449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92450       };
92451     }
92452   }
92453
92454   jresult = (void *)result;
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92460   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92461   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92462   if (director) {
92463     director->swig_connect_director(callback0);
92464   }
92465 }
92466
92467
92468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92469   KeyboardFocusManager arg1 ;
92470   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92471   KeyboardFocusManager *argp1 ;
92472
92473   argp1 = (KeyboardFocusManager *)jarg1;
92474   if (!argp1) {
92475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92476     return ;
92477   }
92478   arg1 = *argp1;
92479   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92480   if (!arg2) {
92481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92482     return ;
92483   }
92484   {
92485     try {
92486       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92487     } catch (std::out_of_range& e) {
92488       {
92489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92490       };
92491     } catch (std::exception& e) {
92492       {
92493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92494       };
92495     } catch (Dali::DaliException e) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92498       };
92499     } catch (...) {
92500       {
92501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92502       };
92503     }
92504   }
92505
92506 }
92507
92508
92509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92510   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92511
92512   arg1 = (std::vector< unsigned int > *)jarg1;
92513   {
92514     try {
92515       (arg1)->clear();
92516     } catch (std::out_of_range& e) {
92517       {
92518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92519       };
92520     } catch (std::exception& e) {
92521       {
92522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92523       };
92524     } catch (Dali::DaliException e) {
92525       {
92526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92527       };
92528     } catch (...) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92531       };
92532     }
92533   }
92534
92535 }
92536
92537
92538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92539   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92540   unsigned int *arg2 = 0 ;
92541   unsigned int temp2 ;
92542
92543   arg1 = (std::vector< unsigned int > *)jarg1;
92544   temp2 = (unsigned int)jarg2;
92545   arg2 = &temp2;
92546   {
92547     try {
92548       (arg1)->push_back((unsigned int const &)*arg2);
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92564       };
92565     }
92566   }
92567
92568 }
92569
92570
92571 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92572   unsigned long jresult ;
92573   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92574   std::vector< unsigned int >::size_type result;
92575
92576   arg1 = (std::vector< unsigned int > *)jarg1;
92577   {
92578     try {
92579       result = ((std::vector< unsigned int > const *)arg1)->size();
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (Dali::DaliException e) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92591       };
92592     } catch (...) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92595       };
92596     }
92597   }
92598
92599   jresult = (unsigned long)result;
92600   return jresult;
92601 }
92602
92603
92604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92605   unsigned long jresult ;
92606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92607   std::vector< unsigned int >::size_type result;
92608
92609   arg1 = (std::vector< unsigned int > *)jarg1;
92610   {
92611     try {
92612       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92613     } catch (std::out_of_range& e) {
92614       {
92615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92616       };
92617     } catch (std::exception& e) {
92618       {
92619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (Dali::DaliException e) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92624       };
92625     } catch (...) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92628       };
92629     }
92630   }
92631
92632   jresult = (unsigned long)result;
92633   return jresult;
92634 }
92635
92636
92637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92639   std::vector< unsigned int >::size_type arg2 ;
92640
92641   arg1 = (std::vector< unsigned int > *)jarg1;
92642   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92643   {
92644     try {
92645       (arg1)->reserve(arg2);
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92653       };
92654     } catch (Dali::DaliException e) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92657       };
92658     } catch (...) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92661       };
92662     }
92663   }
92664
92665 }
92666
92667
92668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92669   void * jresult ;
92670   std::vector< unsigned int > *result = 0 ;
92671
92672   {
92673     try {
92674       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92690       };
92691     }
92692   }
92693
92694   jresult = (void *)result;
92695   return jresult;
92696 }
92697
92698
92699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92700   void * jresult ;
92701   std::vector< unsigned int > *arg1 = 0 ;
92702   std::vector< unsigned int > *result = 0 ;
92703
92704   arg1 = (std::vector< unsigned int > *)jarg1;
92705   if (!arg1) {
92706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92707     return 0;
92708   }
92709   {
92710     try {
92711       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92712     } catch (std::out_of_range& e) {
92713       {
92714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92715       };
92716     } catch (std::exception& e) {
92717       {
92718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (Dali::DaliException e) {
92721       {
92722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92723       };
92724     } catch (...) {
92725       {
92726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92727       };
92728     }
92729   }
92730
92731   jresult = (void *)result;
92732   return jresult;
92733 }
92734
92735
92736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92737   void * jresult ;
92738   int arg1 ;
92739   std::vector< unsigned int > *result = 0 ;
92740
92741   arg1 = (int)jarg1;
92742   {
92743     try {
92744       try {
92745         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92746       }
92747       catch(std::out_of_range &_e) {
92748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92749         return 0;
92750       }
92751
92752     } catch (std::out_of_range& e) {
92753       {
92754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92755       };
92756     } catch (std::exception& e) {
92757       {
92758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92759       };
92760     } catch (Dali::DaliException e) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92763       };
92764     } catch (...) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92767       };
92768     }
92769   }
92770
92771   jresult = (void *)result;
92772   return jresult;
92773 }
92774
92775
92776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92777   unsigned int jresult ;
92778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92779   int arg2 ;
92780   unsigned int result;
92781
92782   arg1 = (std::vector< unsigned int > *)jarg1;
92783   arg2 = (int)jarg2;
92784   {
92785     try {
92786       try {
92787         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92788       }
92789       catch(std::out_of_range &_e) {
92790         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92791         return 0;
92792       }
92793
92794     } catch (std::out_of_range& e) {
92795       {
92796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92797       };
92798     } catch (std::exception& e) {
92799       {
92800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92801       };
92802     } catch (Dali::DaliException e) {
92803       {
92804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92805       };
92806     } catch (...) {
92807       {
92808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92809       };
92810     }
92811   }
92812
92813   jresult = result;
92814   return jresult;
92815 }
92816
92817
92818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92819   unsigned int jresult ;
92820   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92821   int arg2 ;
92822   unsigned int *result = 0 ;
92823
92824   arg1 = (std::vector< unsigned int > *)jarg1;
92825   arg2 = (int)jarg2;
92826   {
92827     try {
92828       try {
92829         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92830       }
92831       catch(std::out_of_range &_e) {
92832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92833         return 0;
92834       }
92835
92836     } catch (std::out_of_range& e) {
92837       {
92838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92839       };
92840     } catch (std::exception& e) {
92841       {
92842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (Dali::DaliException e) {
92845       {
92846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92847       };
92848     } catch (...) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92851       };
92852     }
92853   }
92854
92855   jresult = *result;
92856   return jresult;
92857 }
92858
92859
92860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92861   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92862   int arg2 ;
92863   unsigned int *arg3 = 0 ;
92864   unsigned int temp3 ;
92865
92866   arg1 = (std::vector< unsigned int > *)jarg1;
92867   arg2 = (int)jarg2;
92868   temp3 = (unsigned int)jarg3;
92869   arg3 = &temp3;
92870   {
92871     try {
92872       try {
92873         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92874       }
92875       catch(std::out_of_range &_e) {
92876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92877         return ;
92878       }
92879
92880     } catch (std::out_of_range& e) {
92881       {
92882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92883       };
92884     } catch (std::exception& e) {
92885       {
92886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92887       };
92888     } catch (Dali::DaliException e) {
92889       {
92890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92891       };
92892     } catch (...) {
92893       {
92894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92895       };
92896     }
92897   }
92898
92899 }
92900
92901
92902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92903   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92904   std::vector< unsigned int > *arg2 = 0 ;
92905
92906   arg1 = (std::vector< unsigned int > *)jarg1;
92907   arg2 = (std::vector< unsigned int > *)jarg2;
92908   if (!arg2) {
92909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92910     return ;
92911   }
92912   {
92913     try {
92914       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92915     } catch (std::out_of_range& e) {
92916       {
92917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92918       };
92919     } catch (std::exception& e) {
92920       {
92921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92922       };
92923     } catch (Dali::DaliException e) {
92924       {
92925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92926       };
92927     } catch (...) {
92928       {
92929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92930       };
92931     }
92932   }
92933
92934 }
92935
92936
92937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92938   void * jresult ;
92939   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92940   int arg2 ;
92941   int arg3 ;
92942   std::vector< unsigned int > *result = 0 ;
92943
92944   arg1 = (std::vector< unsigned int > *)jarg1;
92945   arg2 = (int)jarg2;
92946   arg3 = (int)jarg3;
92947   {
92948     try {
92949       try {
92950         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92951       }
92952       catch(std::out_of_range &_e) {
92953         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92954         return 0;
92955       }
92956       catch(std::invalid_argument &_e) {
92957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92958         return 0;
92959       }
92960
92961     } catch (std::out_of_range& e) {
92962       {
92963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92964       };
92965     } catch (std::exception& e) {
92966       {
92967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92968       };
92969     } catch (Dali::DaliException e) {
92970       {
92971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92972       };
92973     } catch (...) {
92974       {
92975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92976       };
92977     }
92978   }
92979
92980   jresult = (void *)result;
92981   return jresult;
92982 }
92983
92984
92985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92986   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92987   int arg2 ;
92988   unsigned int *arg3 = 0 ;
92989   unsigned int temp3 ;
92990
92991   arg1 = (std::vector< unsigned int > *)jarg1;
92992   arg2 = (int)jarg2;
92993   temp3 = (unsigned int)jarg3;
92994   arg3 = &temp3;
92995   {
92996     try {
92997       try {
92998         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92999       }
93000       catch(std::out_of_range &_e) {
93001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93002         return ;
93003       }
93004
93005     } catch (std::out_of_range& e) {
93006       {
93007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93008       };
93009     } catch (std::exception& e) {
93010       {
93011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (Dali::DaliException e) {
93014       {
93015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93016       };
93017     } catch (...) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93020       };
93021     }
93022   }
93023
93024 }
93025
93026
93027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93028   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93029   int arg2 ;
93030   std::vector< unsigned int > *arg3 = 0 ;
93031
93032   arg1 = (std::vector< unsigned int > *)jarg1;
93033   arg2 = (int)jarg2;
93034   arg3 = (std::vector< unsigned int > *)jarg3;
93035   if (!arg3) {
93036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93037     return ;
93038   }
93039   {
93040     try {
93041       try {
93042         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93043       }
93044       catch(std::out_of_range &_e) {
93045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93046         return ;
93047       }
93048
93049     } catch (std::out_of_range& e) {
93050       {
93051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93052       };
93053     } catch (std::exception& e) {
93054       {
93055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93056       };
93057     } catch (Dali::DaliException e) {
93058       {
93059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93060       };
93061     } catch (...) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93064       };
93065     }
93066   }
93067
93068 }
93069
93070
93071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93072   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93073   int arg2 ;
93074
93075   arg1 = (std::vector< unsigned int > *)jarg1;
93076   arg2 = (int)jarg2;
93077   {
93078     try {
93079       try {
93080         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93081       }
93082       catch(std::out_of_range &_e) {
93083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93084         return ;
93085       }
93086
93087     } catch (std::out_of_range& e) {
93088       {
93089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93090       };
93091     } catch (std::exception& e) {
93092       {
93093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93094       };
93095     } catch (Dali::DaliException e) {
93096       {
93097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93098       };
93099     } catch (...) {
93100       {
93101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93102       };
93103     }
93104   }
93105
93106 }
93107
93108
93109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93110   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93111   int arg2 ;
93112   int arg3 ;
93113
93114   arg1 = (std::vector< unsigned int > *)jarg1;
93115   arg2 = (int)jarg2;
93116   arg3 = (int)jarg3;
93117   {
93118     try {
93119       try {
93120         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93121       }
93122       catch(std::out_of_range &_e) {
93123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93124         return ;
93125       }
93126       catch(std::invalid_argument &_e) {
93127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93128         return ;
93129       }
93130
93131     } catch (std::out_of_range& e) {
93132       {
93133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93134       };
93135     } catch (std::exception& e) {
93136       {
93137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93138       };
93139     } catch (Dali::DaliException e) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93142       };
93143     } catch (...) {
93144       {
93145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93146       };
93147     }
93148   }
93149
93150 }
93151
93152
93153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93154   void * jresult ;
93155   unsigned int *arg1 = 0 ;
93156   int arg2 ;
93157   unsigned int temp1 ;
93158   std::vector< unsigned int > *result = 0 ;
93159
93160   temp1 = (unsigned int)jarg1;
93161   arg1 = &temp1;
93162   arg2 = (int)jarg2;
93163   {
93164     try {
93165       try {
93166         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93167       }
93168       catch(std::out_of_range &_e) {
93169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93170         return 0;
93171       }
93172
93173     } catch (std::out_of_range& e) {
93174       {
93175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93176       };
93177     } catch (std::exception& e) {
93178       {
93179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93180       };
93181     } catch (Dali::DaliException e) {
93182       {
93183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93184       };
93185     } catch (...) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93188       };
93189     }
93190   }
93191
93192   jresult = (void *)result;
93193   return jresult;
93194 }
93195
93196
93197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93198   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93199
93200   arg1 = (std::vector< unsigned int > *)jarg1;
93201   {
93202     try {
93203       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93204     } catch (std::out_of_range& e) {
93205       {
93206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93207       };
93208     } catch (std::exception& e) {
93209       {
93210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93211       };
93212     } catch (Dali::DaliException e) {
93213       {
93214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93215       };
93216     } catch (...) {
93217       {
93218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93219       };
93220     }
93221   }
93222
93223 }
93224
93225
93226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93227   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93228   int arg2 ;
93229   int arg3 ;
93230
93231   arg1 = (std::vector< unsigned int > *)jarg1;
93232   arg2 = (int)jarg2;
93233   arg3 = (int)jarg3;
93234   {
93235     try {
93236       try {
93237         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93238       }
93239       catch(std::out_of_range &_e) {
93240         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93241         return ;
93242       }
93243       catch(std::invalid_argument &_e) {
93244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93245         return ;
93246       }
93247
93248     } catch (std::out_of_range& e) {
93249       {
93250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (std::exception& e) {
93253       {
93254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93255       };
93256     } catch (Dali::DaliException e) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93259       };
93260     } catch (...) {
93261       {
93262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93263       };
93264     }
93265   }
93266
93267 }
93268
93269
93270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93271   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93272   int arg2 ;
93273   std::vector< unsigned int > *arg3 = 0 ;
93274
93275   arg1 = (std::vector< unsigned int > *)jarg1;
93276   arg2 = (int)jarg2;
93277   arg3 = (std::vector< unsigned int > *)jarg3;
93278   if (!arg3) {
93279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93280     return ;
93281   }
93282   {
93283     try {
93284       try {
93285         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93286       }
93287       catch(std::out_of_range &_e) {
93288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93289         return ;
93290       }
93291
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93299       };
93300     } catch (Dali::DaliException e) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93303       };
93304     } catch (...) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93307       };
93308     }
93309   }
93310
93311 }
93312
93313
93314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93315   unsigned int jresult ;
93316   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93317   unsigned int *arg2 = 0 ;
93318   unsigned int temp2 ;
93319   bool result;
93320
93321   arg1 = (std::vector< unsigned int > *)jarg1;
93322   temp2 = (unsigned int)jarg2;
93323   arg2 = &temp2;
93324   {
93325     try {
93326       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93327     } catch (std::out_of_range& e) {
93328       {
93329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93330       };
93331     } catch (std::exception& e) {
93332       {
93333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93334       };
93335     } catch (Dali::DaliException e) {
93336       {
93337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93338       };
93339     } catch (...) {
93340       {
93341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93342       };
93343     }
93344   }
93345
93346   jresult = result;
93347   return jresult;
93348 }
93349
93350
93351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93352   int jresult ;
93353   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93354   unsigned int *arg2 = 0 ;
93355   unsigned int temp2 ;
93356   int result;
93357
93358   arg1 = (std::vector< unsigned int > *)jarg1;
93359   temp2 = (unsigned int)jarg2;
93360   arg2 = &temp2;
93361   {
93362     try {
93363       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93364     } catch (std::out_of_range& e) {
93365       {
93366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93367       };
93368     } catch (std::exception& e) {
93369       {
93370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93371       };
93372     } catch (Dali::DaliException e) {
93373       {
93374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93375       };
93376     } catch (...) {
93377       {
93378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93379       };
93380     }
93381   }
93382
93383   jresult = result;
93384   return jresult;
93385 }
93386
93387
93388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93389   int jresult ;
93390   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93391   unsigned int *arg2 = 0 ;
93392   unsigned int temp2 ;
93393   int result;
93394
93395   arg1 = (std::vector< unsigned int > *)jarg1;
93396   temp2 = (unsigned int)jarg2;
93397   arg2 = &temp2;
93398   {
93399     try {
93400       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93401     } catch (std::out_of_range& e) {
93402       {
93403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93404       };
93405     } catch (std::exception& e) {
93406       {
93407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (Dali::DaliException e) {
93410       {
93411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93412       };
93413     } catch (...) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93416       };
93417     }
93418   }
93419
93420   jresult = result;
93421   return jresult;
93422 }
93423
93424
93425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93426   unsigned int jresult ;
93427   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93428   unsigned int *arg2 = 0 ;
93429   unsigned int temp2 ;
93430   bool result;
93431
93432   arg1 = (std::vector< unsigned int > *)jarg1;
93433   temp2 = (unsigned int)jarg2;
93434   arg2 = &temp2;
93435   {
93436     try {
93437       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93438     } catch (std::out_of_range& e) {
93439       {
93440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93441       };
93442     } catch (std::exception& e) {
93443       {
93444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (Dali::DaliException e) {
93447       {
93448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93449       };
93450     } catch (...) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93453       };
93454     }
93455   }
93456
93457   jresult = result;
93458   return jresult;
93459 }
93460
93461
93462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93463   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93464
93465   arg1 = (std::vector< unsigned int > *)jarg1;
93466   {
93467     try {
93468       delete arg1;
93469     } catch (std::out_of_range& e) {
93470       {
93471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93472       };
93473     } catch (std::exception& e) {
93474       {
93475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93476       };
93477     } catch (Dali::DaliException e) {
93478       {
93479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93480       };
93481     } catch (...) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93484       };
93485     }
93486   }
93487
93488 }
93489
93490
93491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93492   void * jresult ;
93493   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93494
93495   {
93496     try {
93497       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93498     } catch (std::out_of_range& e) {
93499       {
93500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93501       };
93502     } catch (std::exception& e) {
93503       {
93504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93505       };
93506     } catch (Dali::DaliException e) {
93507       {
93508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93509       };
93510     } catch (...) {
93511       {
93512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93513       };
93514     }
93515   }
93516
93517   jresult = (void *)result;
93518   return jresult;
93519 }
93520
93521
93522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93523   void * jresult ;
93524   unsigned int arg1 ;
93525   Dali::Actor arg2 ;
93526   Dali::Actor *argp2 ;
93527   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93528
93529   arg1 = (unsigned int)jarg1;
93530   argp2 = (Dali::Actor *)jarg2;
93531   if (!argp2) {
93532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93533     return 0;
93534   }
93535   arg2 = *argp2;
93536   {
93537     try {
93538       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93539     } catch (std::out_of_range& e) {
93540       {
93541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93542       };
93543     } catch (std::exception& e) {
93544       {
93545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (Dali::DaliException e) {
93548       {
93549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93550       };
93551     } catch (...) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93554       };
93555     }
93556   }
93557
93558   jresult = (void *)result;
93559   return jresult;
93560 }
93561
93562
93563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93564   void * jresult ;
93565   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93566   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93567
93568   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93569   if (!arg1) {
93570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93571     return 0;
93572   }
93573   {
93574     try {
93575       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93576     } catch (std::out_of_range& e) {
93577       {
93578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93579       };
93580     } catch (std::exception& e) {
93581       {
93582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (Dali::DaliException e) {
93585       {
93586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93587       };
93588     } catch (...) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93591       };
93592     }
93593   }
93594
93595   jresult = (void *)result;
93596   return jresult;
93597 }
93598
93599
93600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93601   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93602   unsigned int arg2 ;
93603
93604   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93605   arg2 = (unsigned int)jarg2;
93606   if (arg1) (arg1)->first = arg2;
93607 }
93608
93609
93610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93611   unsigned int jresult ;
93612   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93613   unsigned int result;
93614
93615   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93616   result = (unsigned int) ((arg1)->first);
93617   jresult = result;
93618   return jresult;
93619 }
93620
93621
93622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93623   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93624   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93625
93626   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93627   arg2 = (Dali::Actor *)jarg2;
93628   if (arg1) (arg1)->second = *arg2;
93629 }
93630
93631
93632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93633   void * jresult ;
93634   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93635   Dali::Actor *result = 0 ;
93636
93637   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93638   result = (Dali::Actor *)& ((arg1)->second);
93639   jresult = (void *)result;
93640   return jresult;
93641 }
93642
93643
93644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93645   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93646
93647   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93648   {
93649     try {
93650       delete arg1;
93651     } catch (std::out_of_range& e) {
93652       {
93653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93654       };
93655     } catch (std::exception& e) {
93656       {
93657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93658       };
93659     } catch (Dali::DaliException e) {
93660       {
93661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93662       };
93663     } catch (...) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93666       };
93667     }
93668   }
93669
93670 }
93671
93672
93673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93674   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93675
93676   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93677   {
93678     try {
93679       (arg1)->clear();
93680     } catch (std::out_of_range& e) {
93681       {
93682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93683       };
93684     } catch (std::exception& e) {
93685       {
93686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93687       };
93688     } catch (Dali::DaliException e) {
93689       {
93690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93691       };
93692     } catch (...) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93695       };
93696     }
93697   }
93698
93699 }
93700
93701
93702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93703   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93704   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93705
93706   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93707   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93708   if (!arg2) {
93709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93710     return ;
93711   }
93712   {
93713     try {
93714       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93715     } catch (std::out_of_range& e) {
93716       {
93717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93718       };
93719     } catch (std::exception& e) {
93720       {
93721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93722       };
93723     } catch (Dali::DaliException e) {
93724       {
93725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93726       };
93727     } catch (...) {
93728       {
93729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93730       };
93731     }
93732   }
93733
93734 }
93735
93736
93737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93738   unsigned long jresult ;
93739   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93740   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93741
93742   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93743   {
93744     try {
93745       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93746     } catch (std::out_of_range& e) {
93747       {
93748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93749       };
93750     } catch (std::exception& e) {
93751       {
93752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93753       };
93754     } catch (Dali::DaliException e) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93757       };
93758     } catch (...) {
93759       {
93760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93761       };
93762     }
93763   }
93764
93765   jresult = (unsigned long)result;
93766   return jresult;
93767 }
93768
93769
93770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93771   unsigned long jresult ;
93772   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93773   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93774
93775   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93776   {
93777     try {
93778       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (Dali::DaliException e) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93790       };
93791     } catch (...) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93794       };
93795     }
93796   }
93797
93798   jresult = (unsigned long)result;
93799   return jresult;
93800 }
93801
93802
93803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93804   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93805   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93806
93807   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93808   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93809   {
93810     try {
93811       (arg1)->reserve(arg2);
93812     } catch (std::out_of_range& e) {
93813       {
93814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93815       };
93816     } catch (std::exception& e) {
93817       {
93818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93819       };
93820     } catch (Dali::DaliException e) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93823       };
93824     } catch (...) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93827       };
93828     }
93829   }
93830
93831 }
93832
93833
93834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93835   void * jresult ;
93836   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93837
93838   {
93839     try {
93840       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93841     } catch (std::out_of_range& e) {
93842       {
93843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93844       };
93845     } catch (std::exception& e) {
93846       {
93847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (Dali::DaliException e) {
93850       {
93851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93852       };
93853     } catch (...) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93856       };
93857     }
93858   }
93859
93860   jresult = (void *)result;
93861   return jresult;
93862 }
93863
93864
93865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93866   void * jresult ;
93867   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93868   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93869
93870   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93871   if (!arg1) {
93872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93873     return 0;
93874   }
93875   {
93876     try {
93877       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);
93878     } catch (std::out_of_range& e) {
93879       {
93880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93881       };
93882     } catch (std::exception& e) {
93883       {
93884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93885       };
93886     } catch (Dali::DaliException e) {
93887       {
93888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93889       };
93890     } catch (...) {
93891       {
93892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93893       };
93894     }
93895   }
93896
93897   jresult = (void *)result;
93898   return jresult;
93899 }
93900
93901
93902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93903   void * jresult ;
93904   int arg1 ;
93905   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93906
93907   arg1 = (int)jarg1;
93908   {
93909     try {
93910       try {
93911         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);
93912       }
93913       catch(std::out_of_range &_e) {
93914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93915         return 0;
93916       }
93917
93918     } catch (std::out_of_range& e) {
93919       {
93920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93921       };
93922     } catch (std::exception& e) {
93923       {
93924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93925       };
93926     } catch (Dali::DaliException e) {
93927       {
93928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93929       };
93930     } catch (...) {
93931       {
93932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93933       };
93934     }
93935   }
93936
93937   jresult = (void *)result;
93938   return jresult;
93939 }
93940
93941
93942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93943   void * jresult ;
93944   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93945   int arg2 ;
93946   std::pair< unsigned int,Dali::Actor > result;
93947
93948   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93949   arg2 = (int)jarg2;
93950   {
93951     try {
93952       try {
93953         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93954       }
93955       catch(std::out_of_range &_e) {
93956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93957         return 0;
93958       }
93959
93960     } catch (std::out_of_range& e) {
93961       {
93962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (std::exception& e) {
93965       {
93966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93967       };
93968     } catch (Dali::DaliException e) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93971       };
93972     } catch (...) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93975       };
93976     }
93977   }
93978
93979   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93980   return jresult;
93981 }
93982
93983
93984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93985   void * jresult ;
93986   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93987   int arg2 ;
93988   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93989
93990   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93991   arg2 = (int)jarg2;
93992   {
93993     try {
93994       try {
93995         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93996       }
93997       catch(std::out_of_range &_e) {
93998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93999         return 0;
94000       }
94001
94002     } catch (std::out_of_range& e) {
94003       {
94004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94005       };
94006     } catch (std::exception& e) {
94007       {
94008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94009       };
94010     } catch (Dali::DaliException e) {
94011       {
94012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94013       };
94014     } catch (...) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94017       };
94018     }
94019   }
94020
94021   jresult = (void *)result;
94022   return jresult;
94023 }
94024
94025
94026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94027   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94028   int arg2 ;
94029   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94030
94031   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94032   arg2 = (int)jarg2;
94033   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94034   if (!arg3) {
94035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94036     return ;
94037   }
94038   {
94039     try {
94040       try {
94041         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);
94042       }
94043       catch(std::out_of_range &_e) {
94044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94045         return ;
94046       }
94047
94048     } catch (std::out_of_range& e) {
94049       {
94050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94051       };
94052     } catch (std::exception& e) {
94053       {
94054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (Dali::DaliException e) {
94057       {
94058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94059       };
94060     } catch (...) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94063       };
94064     }
94065   }
94066
94067 }
94068
94069
94070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94072   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94073
94074   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94075   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94076   if (!arg2) {
94077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94078     return ;
94079   }
94080   {
94081     try {
94082       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);
94083     } catch (std::out_of_range& e) {
94084       {
94085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94086       };
94087     } catch (std::exception& e) {
94088       {
94089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94090       };
94091     } catch (Dali::DaliException e) {
94092       {
94093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94094       };
94095     } catch (...) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94098       };
94099     }
94100   }
94101
94102 }
94103
94104
94105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94106   void * jresult ;
94107   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94108   int arg2 ;
94109   int arg3 ;
94110   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94111
94112   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94113   arg2 = (int)jarg2;
94114   arg3 = (int)jarg3;
94115   {
94116     try {
94117       try {
94118         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);
94119       }
94120       catch(std::out_of_range &_e) {
94121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94122         return 0;
94123       }
94124       catch(std::invalid_argument &_e) {
94125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94126         return 0;
94127       }
94128
94129     } catch (std::out_of_range& e) {
94130       {
94131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94132       };
94133     } catch (std::exception& e) {
94134       {
94135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94136       };
94137     } catch (Dali::DaliException e) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94140       };
94141     } catch (...) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94144       };
94145     }
94146   }
94147
94148   jresult = (void *)result;
94149   return jresult;
94150 }
94151
94152
94153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94154   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94155   int arg2 ;
94156   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94157
94158   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94159   arg2 = (int)jarg2;
94160   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94161   if (!arg3) {
94162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94163     return ;
94164   }
94165   {
94166     try {
94167       try {
94168         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);
94169       }
94170       catch(std::out_of_range &_e) {
94171         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94172         return ;
94173       }
94174
94175     } catch (std::out_of_range& e) {
94176       {
94177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94178       };
94179     } catch (std::exception& e) {
94180       {
94181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94182       };
94183     } catch (Dali::DaliException e) {
94184       {
94185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94186       };
94187     } catch (...) {
94188       {
94189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94190       };
94191     }
94192   }
94193
94194 }
94195
94196
94197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94198   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94199   int arg2 ;
94200   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94201
94202   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94203   arg2 = (int)jarg2;
94204   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94205   if (!arg3) {
94206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94207     return ;
94208   }
94209   {
94210     try {
94211       try {
94212         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);
94213       }
94214       catch(std::out_of_range &_e) {
94215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94216         return ;
94217       }
94218
94219     } catch (std::out_of_range& e) {
94220       {
94221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94222       };
94223     } catch (std::exception& e) {
94224       {
94225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94226       };
94227     } catch (Dali::DaliException e) {
94228       {
94229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94230       };
94231     } catch (...) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94234       };
94235     }
94236   }
94237
94238 }
94239
94240
94241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94242   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94243   int arg2 ;
94244
94245   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94246   arg2 = (int)jarg2;
94247   {
94248     try {
94249       try {
94250         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94251       }
94252       catch(std::out_of_range &_e) {
94253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94254         return ;
94255       }
94256
94257     } catch (std::out_of_range& e) {
94258       {
94259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94260       };
94261     } catch (std::exception& e) {
94262       {
94263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94264       };
94265     } catch (Dali::DaliException e) {
94266       {
94267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94268       };
94269     } catch (...) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94272       };
94273     }
94274   }
94275
94276 }
94277
94278
94279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94280   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94281   int arg2 ;
94282   int arg3 ;
94283
94284   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94285   arg2 = (int)jarg2;
94286   arg3 = (int)jarg3;
94287   {
94288     try {
94289       try {
94290         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94291       }
94292       catch(std::out_of_range &_e) {
94293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94294         return ;
94295       }
94296       catch(std::invalid_argument &_e) {
94297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94298         return ;
94299       }
94300
94301     } catch (std::out_of_range& e) {
94302       {
94303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94304       };
94305     } catch (std::exception& e) {
94306       {
94307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94308       };
94309     } catch (Dali::DaliException e) {
94310       {
94311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94312       };
94313     } catch (...) {
94314       {
94315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94316       };
94317     }
94318   }
94319
94320 }
94321
94322
94323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94324   void * jresult ;
94325   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94326   int arg2 ;
94327   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94328
94329   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94330   if (!arg1) {
94331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94332     return 0;
94333   }
94334   arg2 = (int)jarg2;
94335   {
94336     try {
94337       try {
94338         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);
94339       }
94340       catch(std::out_of_range &_e) {
94341         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94342         return 0;
94343       }
94344
94345     } catch (std::out_of_range& e) {
94346       {
94347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94348       };
94349     } catch (std::exception& e) {
94350       {
94351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94352       };
94353     } catch (Dali::DaliException e) {
94354       {
94355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94356       };
94357     } catch (...) {
94358       {
94359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94360       };
94361     }
94362   }
94363
94364   jresult = (void *)result;
94365   return jresult;
94366 }
94367
94368
94369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94370   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94371
94372   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94373   {
94374     try {
94375       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94376     } catch (std::out_of_range& e) {
94377       {
94378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94379       };
94380     } catch (std::exception& e) {
94381       {
94382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (Dali::DaliException e) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94387       };
94388     } catch (...) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94391       };
94392     }
94393   }
94394
94395 }
94396
94397
94398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94399   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94400   int arg2 ;
94401   int arg3 ;
94402
94403   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94404   arg2 = (int)jarg2;
94405   arg3 = (int)jarg3;
94406   {
94407     try {
94408       try {
94409         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94410       }
94411       catch(std::out_of_range &_e) {
94412         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94413         return ;
94414       }
94415       catch(std::invalid_argument &_e) {
94416         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94417         return ;
94418       }
94419
94420     } catch (std::out_of_range& e) {
94421       {
94422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94423       };
94424     } catch (std::exception& e) {
94425       {
94426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94427       };
94428     } catch (Dali::DaliException e) {
94429       {
94430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94431       };
94432     } catch (...) {
94433       {
94434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94435       };
94436     }
94437   }
94438
94439 }
94440
94441
94442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94443   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94444   int arg2 ;
94445   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94446
94447   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94448   arg2 = (int)jarg2;
94449   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94450   if (!arg3) {
94451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94452     return ;
94453   }
94454   {
94455     try {
94456       try {
94457         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);
94458       }
94459       catch(std::out_of_range &_e) {
94460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94461         return ;
94462       }
94463
94464     } catch (std::out_of_range& e) {
94465       {
94466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94467       };
94468     } catch (std::exception& e) {
94469       {
94470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94471       };
94472     } catch (Dali::DaliException e) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94475       };
94476     } catch (...) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94479       };
94480     }
94481   }
94482
94483 }
94484
94485
94486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94487   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94488
94489   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94490   {
94491     try {
94492       delete arg1;
94493     } catch (std::out_of_range& e) {
94494       {
94495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94496       };
94497     } catch (std::exception& e) {
94498       {
94499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94500       };
94501     } catch (Dali::DaliException e) {
94502       {
94503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94504       };
94505     } catch (...) {
94506       {
94507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94508       };
94509     }
94510   }
94511
94512 }
94513
94514
94515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94516   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94517
94518   arg1 = (std::vector< Dali::Actor > *)jarg1;
94519   {
94520     try {
94521       (arg1)->clear();
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94537       };
94538     }
94539   }
94540
94541 }
94542
94543
94544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94545   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94546   Dali::Actor *arg2 = 0 ;
94547
94548   arg1 = (std::vector< Dali::Actor > *)jarg1;
94549   arg2 = (Dali::Actor *)jarg2;
94550   if (!arg2) {
94551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94552     return ;
94553   }
94554   {
94555     try {
94556       (arg1)->push_back((Dali::Actor const &)*arg2);
94557     } catch (std::out_of_range& e) {
94558       {
94559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94560       };
94561     } catch (std::exception& e) {
94562       {
94563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94564       };
94565     } catch (Dali::DaliException e) {
94566       {
94567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94568       };
94569     } catch (...) {
94570       {
94571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94572       };
94573     }
94574   }
94575
94576 }
94577
94578
94579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94580   unsigned long jresult ;
94581   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94582   std::vector< Dali::Actor >::size_type result;
94583
94584   arg1 = (std::vector< Dali::Actor > *)jarg1;
94585   {
94586     try {
94587       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94588     } catch (std::out_of_range& e) {
94589       {
94590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (std::exception& e) {
94593       {
94594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94595       };
94596     } catch (Dali::DaliException e) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94599       };
94600     } catch (...) {
94601       {
94602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94603       };
94604     }
94605   }
94606
94607   jresult = (unsigned long)result;
94608   return jresult;
94609 }
94610
94611
94612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94613   unsigned long jresult ;
94614   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94615   std::vector< Dali::Actor >::size_type result;
94616
94617   arg1 = (std::vector< Dali::Actor > *)jarg1;
94618   {
94619     try {
94620       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94636       };
94637     }
94638   }
94639
94640   jresult = (unsigned long)result;
94641   return jresult;
94642 }
94643
94644
94645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94646   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94647   std::vector< Dali::Actor >::size_type arg2 ;
94648
94649   arg1 = (std::vector< Dali::Actor > *)jarg1;
94650   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94651   {
94652     try {
94653       (arg1)->reserve(arg2);
94654     } catch (std::out_of_range& e) {
94655       {
94656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94657       };
94658     } catch (std::exception& e) {
94659       {
94660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94661       };
94662     } catch (Dali::DaliException e) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94665       };
94666     } catch (...) {
94667       {
94668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94669       };
94670     }
94671   }
94672
94673 }
94674
94675
94676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94677   void * jresult ;
94678   std::vector< Dali::Actor > *result = 0 ;
94679
94680   {
94681     try {
94682       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94683     } catch (std::out_of_range& e) {
94684       {
94685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94686       };
94687     } catch (std::exception& e) {
94688       {
94689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94690       };
94691     } catch (Dali::DaliException e) {
94692       {
94693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94694       };
94695     } catch (...) {
94696       {
94697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94698       };
94699     }
94700   }
94701
94702   jresult = (void *)result;
94703   return jresult;
94704 }
94705
94706
94707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94708   void * jresult ;
94709   std::vector< Dali::Actor > *arg1 = 0 ;
94710   std::vector< Dali::Actor > *result = 0 ;
94711
94712   arg1 = (std::vector< Dali::Actor > *)jarg1;
94713   if (!arg1) {
94714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94715     return 0;
94716   }
94717   {
94718     try {
94719       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94720     } catch (std::out_of_range& e) {
94721       {
94722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94723       };
94724     } catch (std::exception& e) {
94725       {
94726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94727       };
94728     } catch (Dali::DaliException e) {
94729       {
94730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94731       };
94732     } catch (...) {
94733       {
94734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94735       };
94736     }
94737   }
94738
94739   jresult = (void *)result;
94740   return jresult;
94741 }
94742
94743
94744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94745   void * jresult ;
94746   int arg1 ;
94747   std::vector< Dali::Actor > *result = 0 ;
94748
94749   arg1 = (int)jarg1;
94750   {
94751     try {
94752       try {
94753         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94754       }
94755       catch(std::out_of_range &_e) {
94756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94757         return 0;
94758       }
94759
94760     } catch (std::out_of_range& e) {
94761       {
94762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94763       };
94764     } catch (std::exception& e) {
94765       {
94766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94767       };
94768     } catch (Dali::DaliException e) {
94769       {
94770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94771       };
94772     } catch (...) {
94773       {
94774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94775       };
94776     }
94777   }
94778
94779   jresult = (void *)result;
94780   return jresult;
94781 }
94782
94783
94784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94785   void * jresult ;
94786   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94787   int arg2 ;
94788   Dali::Actor result;
94789
94790   arg1 = (std::vector< Dali::Actor > *)jarg1;
94791   arg2 = (int)jarg2;
94792   {
94793     try {
94794       try {
94795         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94796       }
94797       catch(std::out_of_range &_e) {
94798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94799         return 0;
94800       }
94801
94802     } catch (std::out_of_range& e) {
94803       {
94804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94805       };
94806     } catch (std::exception& e) {
94807       {
94808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94809       };
94810     } catch (Dali::DaliException e) {
94811       {
94812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94813       };
94814     } catch (...) {
94815       {
94816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94817       };
94818     }
94819   }
94820
94821   jresult = new Dali::Actor((const Dali::Actor &)result);
94822   return jresult;
94823 }
94824
94825
94826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94827   void * jresult ;
94828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94829   int arg2 ;
94830   Dali::Actor *result = 0 ;
94831
94832   arg1 = (std::vector< Dali::Actor > *)jarg1;
94833   arg2 = (int)jarg2;
94834   {
94835     try {
94836       try {
94837         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94838       }
94839       catch(std::out_of_range &_e) {
94840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94841         return 0;
94842       }
94843
94844     } catch (std::out_of_range& e) {
94845       {
94846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94847       };
94848     } catch (std::exception& e) {
94849       {
94850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94851       };
94852     } catch (Dali::DaliException e) {
94853       {
94854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94855       };
94856     } catch (...) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94859       };
94860     }
94861   }
94862
94863   jresult = (void *)result;
94864   return jresult;
94865 }
94866
94867
94868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94869   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94870   int arg2 ;
94871   Dali::Actor *arg3 = 0 ;
94872
94873   arg1 = (std::vector< Dali::Actor > *)jarg1;
94874   arg2 = (int)jarg2;
94875   arg3 = (Dali::Actor *)jarg3;
94876   if (!arg3) {
94877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94878     return ;
94879   }
94880   {
94881     try {
94882       try {
94883         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94884       }
94885       catch(std::out_of_range &_e) {
94886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94887         return ;
94888       }
94889
94890     } catch (std::out_of_range& e) {
94891       {
94892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94893       };
94894     } catch (std::exception& e) {
94895       {
94896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94897       };
94898     } catch (Dali::DaliException e) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94901       };
94902     } catch (...) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94905       };
94906     }
94907   }
94908
94909 }
94910
94911
94912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94913   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94914   std::vector< Dali::Actor > *arg2 = 0 ;
94915
94916   arg1 = (std::vector< Dali::Actor > *)jarg1;
94917   arg2 = (std::vector< Dali::Actor > *)jarg2;
94918   if (!arg2) {
94919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94920     return ;
94921   }
94922   {
94923     try {
94924       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94925     } catch (std::out_of_range& e) {
94926       {
94927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94928       };
94929     } catch (std::exception& e) {
94930       {
94931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94932       };
94933     } catch (Dali::DaliException e) {
94934       {
94935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94936       };
94937     } catch (...) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94940       };
94941     }
94942   }
94943
94944 }
94945
94946
94947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94948   void * jresult ;
94949   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94950   int arg2 ;
94951   int arg3 ;
94952   std::vector< Dali::Actor > *result = 0 ;
94953
94954   arg1 = (std::vector< Dali::Actor > *)jarg1;
94955   arg2 = (int)jarg2;
94956   arg3 = (int)jarg3;
94957   {
94958     try {
94959       try {
94960         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94961       }
94962       catch(std::out_of_range &_e) {
94963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94964         return 0;
94965       }
94966       catch(std::invalid_argument &_e) {
94967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94968         return 0;
94969       }
94970
94971     } catch (std::out_of_range& e) {
94972       {
94973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94974       };
94975     } catch (std::exception& e) {
94976       {
94977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94978       };
94979     } catch (Dali::DaliException e) {
94980       {
94981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94982       };
94983     } catch (...) {
94984       {
94985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94986       };
94987     }
94988   }
94989
94990   jresult = (void *)result;
94991   return jresult;
94992 }
94993
94994
94995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94996   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94997   int arg2 ;
94998   Dali::Actor *arg3 = 0 ;
94999
95000   arg1 = (std::vector< Dali::Actor > *)jarg1;
95001   arg2 = (int)jarg2;
95002   arg3 = (Dali::Actor *)jarg3;
95003   if (!arg3) {
95004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95005     return ;
95006   }
95007   {
95008     try {
95009       try {
95010         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95011       }
95012       catch(std::out_of_range &_e) {
95013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95014         return ;
95015       }
95016
95017     } catch (std::out_of_range& e) {
95018       {
95019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95020       };
95021     } catch (std::exception& e) {
95022       {
95023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95024       };
95025     } catch (Dali::DaliException e) {
95026       {
95027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95028       };
95029     } catch (...) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95032       };
95033     }
95034   }
95035
95036 }
95037
95038
95039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95040   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95041   int arg2 ;
95042   std::vector< Dali::Actor > *arg3 = 0 ;
95043
95044   arg1 = (std::vector< Dali::Actor > *)jarg1;
95045   arg2 = (int)jarg2;
95046   arg3 = (std::vector< Dali::Actor > *)jarg3;
95047   if (!arg3) {
95048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95049     return ;
95050   }
95051   {
95052     try {
95053       try {
95054         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95055       }
95056       catch(std::out_of_range &_e) {
95057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95058         return ;
95059       }
95060
95061     } catch (std::out_of_range& e) {
95062       {
95063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95064       };
95065     } catch (std::exception& e) {
95066       {
95067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95068       };
95069     } catch (Dali::DaliException e) {
95070       {
95071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95072       };
95073     } catch (...) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95076       };
95077     }
95078   }
95079
95080 }
95081
95082
95083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95084   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95085   int arg2 ;
95086
95087   arg1 = (std::vector< Dali::Actor > *)jarg1;
95088   arg2 = (int)jarg2;
95089   {
95090     try {
95091       try {
95092         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95093       }
95094       catch(std::out_of_range &_e) {
95095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95096         return ;
95097       }
95098
95099     } catch (std::out_of_range& e) {
95100       {
95101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95102       };
95103     } catch (std::exception& e) {
95104       {
95105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95106       };
95107     } catch (Dali::DaliException e) {
95108       {
95109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95110       };
95111     } catch (...) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95114       };
95115     }
95116   }
95117
95118 }
95119
95120
95121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95122   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95123   int arg2 ;
95124   int arg3 ;
95125
95126   arg1 = (std::vector< Dali::Actor > *)jarg1;
95127   arg2 = (int)jarg2;
95128   arg3 = (int)jarg3;
95129   {
95130     try {
95131       try {
95132         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95133       }
95134       catch(std::out_of_range &_e) {
95135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95136         return ;
95137       }
95138       catch(std::invalid_argument &_e) {
95139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95140         return ;
95141       }
95142
95143     } catch (std::out_of_range& e) {
95144       {
95145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95146       };
95147     } catch (std::exception& e) {
95148       {
95149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95150       };
95151     } catch (Dali::DaliException e) {
95152       {
95153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95154       };
95155     } catch (...) {
95156       {
95157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95158       };
95159     }
95160   }
95161
95162 }
95163
95164
95165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95166   void * jresult ;
95167   Dali::Actor *arg1 = 0 ;
95168   int arg2 ;
95169   std::vector< Dali::Actor > *result = 0 ;
95170
95171   arg1 = (Dali::Actor *)jarg1;
95172   if (!arg1) {
95173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95174     return 0;
95175   }
95176   arg2 = (int)jarg2;
95177   {
95178     try {
95179       try {
95180         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95181       }
95182       catch(std::out_of_range &_e) {
95183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95184         return 0;
95185       }
95186
95187     } catch (std::out_of_range& e) {
95188       {
95189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95190       };
95191     } catch (std::exception& e) {
95192       {
95193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95194       };
95195     } catch (Dali::DaliException e) {
95196       {
95197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95198       };
95199     } catch (...) {
95200       {
95201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95202       };
95203     }
95204   }
95205
95206   jresult = (void *)result;
95207   return jresult;
95208 }
95209
95210
95211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95212   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95213
95214   arg1 = (std::vector< Dali::Actor > *)jarg1;
95215   {
95216     try {
95217       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95218     } catch (std::out_of_range& e) {
95219       {
95220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95221       };
95222     } catch (std::exception& e) {
95223       {
95224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95225       };
95226     } catch (Dali::DaliException e) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95229       };
95230     } catch (...) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95233       };
95234     }
95235   }
95236
95237 }
95238
95239
95240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95241   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95242   int arg2 ;
95243   int arg3 ;
95244
95245   arg1 = (std::vector< Dali::Actor > *)jarg1;
95246   arg2 = (int)jarg2;
95247   arg3 = (int)jarg3;
95248   {
95249     try {
95250       try {
95251         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95252       }
95253       catch(std::out_of_range &_e) {
95254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95255         return ;
95256       }
95257       catch(std::invalid_argument &_e) {
95258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95259         return ;
95260       }
95261
95262     } catch (std::out_of_range& e) {
95263       {
95264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95265       };
95266     } catch (std::exception& e) {
95267       {
95268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95269       };
95270     } catch (Dali::DaliException e) {
95271       {
95272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95273       };
95274     } catch (...) {
95275       {
95276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95277       };
95278     }
95279   }
95280
95281 }
95282
95283
95284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95285   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95286   int arg2 ;
95287   std::vector< Dali::Actor > *arg3 = 0 ;
95288
95289   arg1 = (std::vector< Dali::Actor > *)jarg1;
95290   arg2 = (int)jarg2;
95291   arg3 = (std::vector< Dali::Actor > *)jarg3;
95292   if (!arg3) {
95293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95294     return ;
95295   }
95296   {
95297     try {
95298       try {
95299         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95300       }
95301       catch(std::out_of_range &_e) {
95302         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95303         return ;
95304       }
95305
95306     } catch (std::out_of_range& e) {
95307       {
95308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95309       };
95310     } catch (std::exception& e) {
95311       {
95312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95313       };
95314     } catch (Dali::DaliException e) {
95315       {
95316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95317       };
95318     } catch (...) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95321       };
95322     }
95323   }
95324
95325 }
95326
95327
95328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95329   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95330
95331   arg1 = (std::vector< Dali::Actor > *)jarg1;
95332   {
95333     try {
95334       delete arg1;
95335     } catch (std::out_of_range& e) {
95336       {
95337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95338       };
95339     } catch (std::exception& e) {
95340       {
95341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95342       };
95343     } catch (Dali::DaliException e) {
95344       {
95345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95346       };
95347     } catch (...) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95350       };
95351     }
95352   }
95353
95354 }
95355
95356
95357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95358   unsigned int jresult ;
95359   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95360   bool result;
95361
95362   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95363   {
95364     try {
95365       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95366     } catch (std::out_of_range& e) {
95367       {
95368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95369       };
95370     } catch (std::exception& e) {
95371       {
95372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95373       };
95374     } catch (Dali::DaliException e) {
95375       {
95376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95377       };
95378     } catch (...) {
95379       {
95380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95381       };
95382     }
95383   }
95384
95385   jresult = result;
95386   return jresult;
95387 }
95388
95389
95390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95391   unsigned long jresult ;
95392   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95393   std::size_t result;
95394
95395   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95396   {
95397     try {
95398       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95399     } catch (std::out_of_range& e) {
95400       {
95401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95402       };
95403     } catch (std::exception& e) {
95404       {
95405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95406       };
95407     } catch (Dali::DaliException e) {
95408       {
95409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95410       };
95411     } catch (...) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95414       };
95415     }
95416   }
95417
95418   jresult = (unsigned long)result;
95419   return jresult;
95420 }
95421
95422
95423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95424   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95425   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95426
95427   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95428   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95429   {
95430     try {
95431       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95432     } catch (std::out_of_range& e) {
95433       {
95434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95435       };
95436     } catch (std::exception& e) {
95437       {
95438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95439       };
95440     } catch (Dali::DaliException e) {
95441       {
95442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95443       };
95444     } catch (...) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95447       };
95448     }
95449   }
95450
95451 }
95452
95453
95454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95455   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95456   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95457
95458   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95459   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95460   {
95461     try {
95462       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95463     } catch (std::out_of_range& e) {
95464       {
95465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95466       };
95467     } catch (std::exception& e) {
95468       {
95469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (Dali::DaliException e) {
95472       {
95473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95474       };
95475     } catch (...) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95478       };
95479     }
95480   }
95481
95482 }
95483
95484
95485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95486   unsigned int jresult ;
95487   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95488   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95489   bool result;
95490
95491   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95492   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95493   if (!arg2) {
95494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95495     return 0;
95496   }
95497   {
95498     try {
95499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95500     } catch (std::out_of_range& e) {
95501       {
95502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95503       };
95504     } catch (std::exception& e) {
95505       {
95506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95507       };
95508     } catch (Dali::DaliException e) {
95509       {
95510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95511       };
95512     } catch (...) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95515       };
95516     }
95517   }
95518
95519   jresult = result;
95520   return jresult;
95521 }
95522
95523
95524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95525   void * jresult ;
95526   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95527
95528   {
95529     try {
95530       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95531     } catch (std::out_of_range& e) {
95532       {
95533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95534       };
95535     } catch (std::exception& e) {
95536       {
95537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95538       };
95539     } catch (Dali::DaliException e) {
95540       {
95541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95542       };
95543     } catch (...) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95546       };
95547     }
95548   }
95549
95550   jresult = (void *)result;
95551   return jresult;
95552 }
95553
95554
95555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95556   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95557
95558   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95559   {
95560     try {
95561       delete arg1;
95562     } catch (std::out_of_range& e) {
95563       {
95564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95565       };
95566     } catch (std::exception& e) {
95567       {
95568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95569       };
95570     } catch (Dali::DaliException e) {
95571       {
95572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95573       };
95574     } catch (...) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95577       };
95578     }
95579   }
95580
95581 }
95582
95583
95584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95585   unsigned int jresult ;
95586   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95587   bool result;
95588
95589   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95590   {
95591     try {
95592       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);
95593     } catch (std::out_of_range& e) {
95594       {
95595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95596       };
95597     } catch (std::exception& e) {
95598       {
95599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95600       };
95601     } catch (Dali::DaliException e) {
95602       {
95603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95604       };
95605     } catch (...) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95608       };
95609     }
95610   }
95611
95612   jresult = result;
95613   return jresult;
95614 }
95615
95616
95617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95618   unsigned long jresult ;
95619   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95620   std::size_t result;
95621
95622   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95623   {
95624     try {
95625       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);
95626     } catch (std::out_of_range& e) {
95627       {
95628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95629       };
95630     } catch (std::exception& e) {
95631       {
95632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (Dali::DaliException e) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95641       };
95642     }
95643   }
95644
95645   jresult = (unsigned long)result;
95646   return jresult;
95647 }
95648
95649
95650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95651   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95652   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95653
95654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95655   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95656   {
95657     try {
95658       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95659     } catch (std::out_of_range& e) {
95660       {
95661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95662       };
95663     } catch (std::exception& e) {
95664       {
95665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95666       };
95667     } catch (Dali::DaliException e) {
95668       {
95669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95670       };
95671     } catch (...) {
95672       {
95673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95674       };
95675     }
95676   }
95677
95678 }
95679
95680
95681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95682   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95683   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95684
95685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95686   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95687   {
95688     try {
95689       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95690     } catch (std::out_of_range& e) {
95691       {
95692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95693       };
95694     } catch (std::exception& e) {
95695       {
95696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95697       };
95698     } catch (Dali::DaliException e) {
95699       {
95700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95701       };
95702     } catch (...) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95705       };
95706     }
95707   }
95708
95709 }
95710
95711
95712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95713   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95714   Dali::Actor arg2 ;
95715   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95716   Dali::Actor *argp2 ;
95717
95718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95719   argp2 = (Dali::Actor *)jarg2;
95720   if (!argp2) {
95721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95722     return ;
95723   }
95724   arg2 = *argp2;
95725   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95726   {
95727     try {
95728       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95729     } catch (std::out_of_range& e) {
95730       {
95731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95732       };
95733     } catch (std::exception& e) {
95734       {
95735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95736       };
95737     } catch (Dali::DaliException e) {
95738       {
95739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95740       };
95741     } catch (...) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95744       };
95745     }
95746   }
95747
95748 }
95749
95750
95751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95752   void * jresult ;
95753   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95754
95755   {
95756     try {
95757       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95758     } catch (std::out_of_range& e) {
95759       {
95760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95761       };
95762     } catch (std::exception& e) {
95763       {
95764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95765       };
95766     } catch (Dali::DaliException e) {
95767       {
95768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95769       };
95770     } catch (...) {
95771       {
95772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95773       };
95774     }
95775   }
95776
95777   jresult = (void *)result;
95778   return jresult;
95779 }
95780
95781
95782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95783   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95784
95785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95786   {
95787     try {
95788       delete arg1;
95789     } catch (std::out_of_range& e) {
95790       {
95791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95792       };
95793     } catch (std::exception& e) {
95794       {
95795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95796       };
95797     } catch (Dali::DaliException e) {
95798       {
95799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95800       };
95801     } catch (...) {
95802       {
95803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95804       };
95805     }
95806   }
95807
95808 }
95809
95810
95811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95812   unsigned int jresult ;
95813   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95814   bool result;
95815
95816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95817   {
95818     try {
95819       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95820     } catch (std::out_of_range& e) {
95821       {
95822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95823       };
95824     } catch (std::exception& e) {
95825       {
95826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95827       };
95828     } catch (Dali::DaliException e) {
95829       {
95830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95831       };
95832     } catch (...) {
95833       {
95834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95835       };
95836     }
95837   }
95838
95839   jresult = result;
95840   return jresult;
95841 }
95842
95843
95844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95845   unsigned long jresult ;
95846   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95847   std::size_t result;
95848
95849   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95850   {
95851     try {
95852       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95853     } catch (std::out_of_range& e) {
95854       {
95855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95856       };
95857     } catch (std::exception& e) {
95858       {
95859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (Dali::DaliException e) {
95862       {
95863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95864       };
95865     } catch (...) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95868       };
95869     }
95870   }
95871
95872   jresult = (unsigned long)result;
95873   return jresult;
95874 }
95875
95876
95877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95878   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95879   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95880
95881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95882   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95883   {
95884     try {
95885       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95886     } catch (std::out_of_range& e) {
95887       {
95888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95889       };
95890     } catch (std::exception& e) {
95891       {
95892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95893       };
95894     } catch (Dali::DaliException e) {
95895       {
95896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95897       };
95898     } catch (...) {
95899       {
95900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95901       };
95902     }
95903   }
95904
95905 }
95906
95907
95908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95909   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95910   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95911
95912   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95913   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95914   {
95915     try {
95916       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95917     } catch (std::out_of_range& e) {
95918       {
95919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95920       };
95921     } catch (std::exception& e) {
95922       {
95923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95924       };
95925     } catch (Dali::DaliException e) {
95926       {
95927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95928       };
95929     } catch (...) {
95930       {
95931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95932       };
95933     }
95934   }
95935
95936 }
95937
95938
95939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95940   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95941   Dali::Actor arg2 ;
95942   Dali::Actor arg3 ;
95943   Dali::Actor *argp2 ;
95944   Dali::Actor *argp3 ;
95945
95946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95947   argp2 = (Dali::Actor *)jarg2;
95948   if (!argp2) {
95949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95950     return ;
95951   }
95952   arg2 = *argp2;
95953   argp3 = (Dali::Actor *)jarg3;
95954   if (!argp3) {
95955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95956     return ;
95957   }
95958   arg3 = *argp3;
95959   {
95960     try {
95961       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95962     } catch (std::out_of_range& e) {
95963       {
95964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95965       };
95966     } catch (std::exception& e) {
95967       {
95968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (Dali::DaliException e) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95973       };
95974     } catch (...) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95977       };
95978     }
95979   }
95980
95981 }
95982
95983
95984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95985   void * jresult ;
95986   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95987
95988   {
95989     try {
95990       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95991     } catch (std::out_of_range& e) {
95992       {
95993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95994       };
95995     } catch (std::exception& e) {
95996       {
95997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95998       };
95999     } catch (Dali::DaliException e) {
96000       {
96001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96002       };
96003     } catch (...) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96006       };
96007     }
96008   }
96009
96010   jresult = (void *)result;
96011   return jresult;
96012 }
96013
96014
96015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96016   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96017
96018   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96019   {
96020     try {
96021       delete arg1;
96022     } catch (std::out_of_range& e) {
96023       {
96024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96025       };
96026     } catch (std::exception& e) {
96027       {
96028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (Dali::DaliException e) {
96031       {
96032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96033       };
96034     } catch (...) {
96035       {
96036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96037       };
96038     }
96039   }
96040
96041 }
96042
96043
96044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96045   unsigned int jresult ;
96046   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96047   bool result;
96048
96049   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96050   {
96051     try {
96052       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96053     } catch (std::out_of_range& e) {
96054       {
96055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96056       };
96057     } catch (std::exception& e) {
96058       {
96059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96060       };
96061     } catch (Dali::DaliException e) {
96062       {
96063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96064       };
96065     } catch (...) {
96066       {
96067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96068       };
96069     }
96070   }
96071
96072   jresult = result;
96073   return jresult;
96074 }
96075
96076
96077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96078   unsigned long jresult ;
96079   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96080   std::size_t result;
96081
96082   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96083   {
96084     try {
96085       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96086     } catch (std::out_of_range& e) {
96087       {
96088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96089       };
96090     } catch (std::exception& e) {
96091       {
96092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (Dali::DaliException e) {
96095       {
96096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96097       };
96098     } catch (...) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96101       };
96102     }
96103   }
96104
96105   jresult = (unsigned long)result;
96106   return jresult;
96107 }
96108
96109
96110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96111   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96112   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96113
96114   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96115   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96116   {
96117     try {
96118       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (Dali::DaliException e) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96134       };
96135     }
96136   }
96137
96138 }
96139
96140
96141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96142   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96143   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96144
96145   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96146   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96147   {
96148     try {
96149       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96150     } catch (std::out_of_range& e) {
96151       {
96152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96153       };
96154     } catch (std::exception& e) {
96155       {
96156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (Dali::DaliException e) {
96159       {
96160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96161       };
96162     } catch (...) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96165       };
96166     }
96167   }
96168
96169 }
96170
96171
96172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96173   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96174   Dali::Actor arg2 ;
96175   bool arg3 ;
96176   Dali::Actor *argp2 ;
96177
96178   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96179   argp2 = (Dali::Actor *)jarg2;
96180   if (!argp2) {
96181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96182     return ;
96183   }
96184   arg2 = *argp2;
96185   arg3 = jarg3 ? true : false;
96186   {
96187     try {
96188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96189     } catch (std::out_of_range& e) {
96190       {
96191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96192       };
96193     } catch (std::exception& e) {
96194       {
96195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (Dali::DaliException e) {
96198       {
96199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96200       };
96201     } catch (...) {
96202       {
96203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96204       };
96205     }
96206   }
96207
96208 }
96209
96210
96211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96212   void * jresult ;
96213   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96214
96215   {
96216     try {
96217       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96218     } catch (std::out_of_range& e) {
96219       {
96220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96221       };
96222     } catch (std::exception& e) {
96223       {
96224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96225       };
96226     } catch (Dali::DaliException e) {
96227       {
96228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96229       };
96230     } catch (...) {
96231       {
96232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96233       };
96234     }
96235   }
96236
96237   jresult = (void *)result;
96238   return jresult;
96239 }
96240
96241
96242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96243   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96244
96245   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96246   {
96247     try {
96248       delete arg1;
96249     } catch (std::out_of_range& e) {
96250       {
96251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (std::exception& e) {
96254       {
96255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96256       };
96257     } catch (Dali::DaliException e) {
96258       {
96259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96260       };
96261     } catch (...) {
96262       {
96263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96264       };
96265     }
96266   }
96267
96268 }
96269
96270
96271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96272   unsigned int jresult ;
96273   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96274   bool result;
96275
96276   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96277   {
96278     try {
96279       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);
96280     } catch (std::out_of_range& e) {
96281       {
96282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96283       };
96284     } catch (std::exception& e) {
96285       {
96286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96287       };
96288     } catch (Dali::DaliException e) {
96289       {
96290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96291       };
96292     } catch (...) {
96293       {
96294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96295       };
96296     }
96297   }
96298
96299   jresult = result;
96300   return jresult;
96301 }
96302
96303
96304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96305   unsigned long jresult ;
96306   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96307   std::size_t result;
96308
96309   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96310   {
96311     try {
96312       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);
96313     } catch (std::out_of_range& e) {
96314       {
96315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96316       };
96317     } catch (std::exception& e) {
96318       {
96319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96320       };
96321     } catch (Dali::DaliException e) {
96322       {
96323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96324       };
96325     } catch (...) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96328       };
96329     }
96330   }
96331
96332   jresult = (unsigned long)result;
96333   return jresult;
96334 }
96335
96336
96337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96338   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96339   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96340
96341   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96342   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96343   {
96344     try {
96345       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96346     } catch (std::out_of_range& e) {
96347       {
96348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96349       };
96350     } catch (std::exception& e) {
96351       {
96352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96353       };
96354     } catch (Dali::DaliException e) {
96355       {
96356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96357       };
96358     } catch (...) {
96359       {
96360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96361       };
96362     }
96363   }
96364
96365 }
96366
96367
96368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96369   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96370   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96371
96372   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96373   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96374   {
96375     try {
96376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96377     } catch (std::out_of_range& e) {
96378       {
96379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96380       };
96381     } catch (std::exception& e) {
96382       {
96383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96384       };
96385     } catch (Dali::DaliException e) {
96386       {
96387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96388       };
96389     } catch (...) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96392       };
96393     }
96394   }
96395
96396 }
96397
96398
96399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96400   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96401   Dali::Toolkit::StyleManager arg2 ;
96402   Dali::StyleChange::Type arg3 ;
96403   Dali::Toolkit::StyleManager *argp2 ;
96404
96405   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96406   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96407   if (!argp2) {
96408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96409     return ;
96410   }
96411   arg2 = *argp2;
96412   arg3 = (Dali::StyleChange::Type)jarg3;
96413   {
96414     try {
96415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96416     } catch (std::out_of_range& e) {
96417       {
96418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96419       };
96420     } catch (std::exception& e) {
96421       {
96422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (Dali::DaliException e) {
96425       {
96426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96427       };
96428     } catch (...) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96431       };
96432     }
96433   }
96434
96435 }
96436
96437
96438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96439   void * jresult ;
96440   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96441
96442   {
96443     try {
96444       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96445     } catch (std::out_of_range& e) {
96446       {
96447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96448       };
96449     } catch (std::exception& e) {
96450       {
96451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96452       };
96453     } catch (Dali::DaliException e) {
96454       {
96455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96456       };
96457     } catch (...) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96460       };
96461     }
96462   }
96463
96464   jresult = (void *)result;
96465   return jresult;
96466 }
96467
96468
96469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96470   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96471
96472   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96473   {
96474     try {
96475       delete arg1;
96476     } catch (std::out_of_range& e) {
96477       {
96478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96479       };
96480     } catch (std::exception& e) {
96481       {
96482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96483       };
96484     } catch (Dali::DaliException e) {
96485       {
96486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96487       };
96488     } catch (...) {
96489       {
96490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96491       };
96492     }
96493   }
96494
96495 }
96496
96497
96498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96499   unsigned int jresult ;
96500   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96501   bool result;
96502
96503   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96504   {
96505     try {
96506       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96507     } catch (std::out_of_range& e) {
96508       {
96509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96510       };
96511     } catch (std::exception& e) {
96512       {
96513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96514       };
96515     } catch (Dali::DaliException e) {
96516       {
96517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96518       };
96519     } catch (...) {
96520       {
96521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96522       };
96523     }
96524   }
96525
96526   jresult = result;
96527   return jresult;
96528 }
96529
96530
96531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96532   unsigned long jresult ;
96533   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96534   std::size_t result;
96535
96536   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96537   {
96538     try {
96539       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96540     } catch (std::out_of_range& e) {
96541       {
96542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96543       };
96544     } catch (std::exception& e) {
96545       {
96546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (Dali::DaliException e) {
96549       {
96550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96551       };
96552     } catch (...) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96555       };
96556     }
96557   }
96558
96559   jresult = (unsigned long)result;
96560   return jresult;
96561 }
96562
96563
96564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96565   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96566   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96567
96568   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96569   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96570   {
96571     try {
96572       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96573     } catch (std::out_of_range& e) {
96574       {
96575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96576       };
96577     } catch (std::exception& e) {
96578       {
96579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96580       };
96581     } catch (Dali::DaliException e) {
96582       {
96583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96584       };
96585     } catch (...) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96588       };
96589     }
96590   }
96591
96592 }
96593
96594
96595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96596   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96597   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96598
96599   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96600   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96601   {
96602     try {
96603       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96604     } catch (std::out_of_range& e) {
96605       {
96606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96607       };
96608     } catch (std::exception& e) {
96609       {
96610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96611       };
96612     } catch (Dali::DaliException e) {
96613       {
96614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96615       };
96616     } catch (...) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96619       };
96620     }
96621   }
96622
96623 }
96624
96625
96626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96627   unsigned int jresult ;
96628   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96629   Dali::Toolkit::Button arg2 ;
96630   Dali::Toolkit::Button *argp2 ;
96631   bool result;
96632
96633   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96634   argp2 = (Dali::Toolkit::Button *)jarg2;
96635   if (!argp2) {
96636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96637     return 0;
96638   }
96639   arg2 = *argp2;
96640   {
96641     try {
96642       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96643     } catch (std::out_of_range& e) {
96644       {
96645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96646       };
96647     } catch (std::exception& e) {
96648       {
96649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96650       };
96651     } catch (Dali::DaliException e) {
96652       {
96653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96654       };
96655     } catch (...) {
96656       {
96657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96658       };
96659     }
96660   }
96661
96662   jresult = result;
96663   return jresult;
96664 }
96665
96666
96667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96668   void * jresult ;
96669   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96670
96671   {
96672     try {
96673       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96674     } catch (std::out_of_range& e) {
96675       {
96676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96677       };
96678     } catch (std::exception& e) {
96679       {
96680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96681       };
96682     } catch (Dali::DaliException e) {
96683       {
96684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96685       };
96686     } catch (...) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96689       };
96690     }
96691   }
96692
96693   jresult = (void *)result;
96694   return jresult;
96695 }
96696
96697
96698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96699   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96700
96701   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96702   {
96703     try {
96704       delete arg1;
96705     } catch (std::out_of_range& e) {
96706       {
96707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96708       };
96709     } catch (std::exception& e) {
96710       {
96711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (Dali::DaliException e) {
96714       {
96715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96716       };
96717     } catch (...) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96720       };
96721     }
96722   }
96723
96724 }
96725
96726
96727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96728   unsigned int jresult ;
96729   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96730   bool result;
96731
96732   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96733   {
96734     try {
96735       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96736     } catch (std::out_of_range& e) {
96737       {
96738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96739       };
96740     } catch (std::exception& e) {
96741       {
96742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96743       };
96744     } catch (Dali::DaliException e) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96747       };
96748     } catch (...) {
96749       {
96750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96751       };
96752     }
96753   }
96754
96755   jresult = result;
96756   return jresult;
96757 }
96758
96759
96760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96761   unsigned long jresult ;
96762   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96763   std::size_t result;
96764
96765   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96766   {
96767     try {
96768       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96769     } catch (std::out_of_range& e) {
96770       {
96771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96772       };
96773     } catch (std::exception& e) {
96774       {
96775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96776       };
96777     } catch (Dali::DaliException e) {
96778       {
96779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96780       };
96781     } catch (...) {
96782       {
96783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96784       };
96785     }
96786   }
96787
96788   jresult = (unsigned long)result;
96789   return jresult;
96790 }
96791
96792
96793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96794   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96795   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96796
96797   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96798   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96799   {
96800     try {
96801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96802     } catch (std::out_of_range& e) {
96803       {
96804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96805       };
96806     } catch (std::exception& e) {
96807       {
96808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96809       };
96810     } catch (Dali::DaliException e) {
96811       {
96812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96813       };
96814     } catch (...) {
96815       {
96816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96817       };
96818     }
96819   }
96820
96821 }
96822
96823
96824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96825   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96826   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96827
96828   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96829   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96830   {
96831     try {
96832       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96833     } catch (std::out_of_range& e) {
96834       {
96835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96836       };
96837     } catch (std::exception& e) {
96838       {
96839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96840       };
96841     } catch (Dali::DaliException e) {
96842       {
96843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96844       };
96845     } catch (...) {
96846       {
96847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96848       };
96849     }
96850   }
96851
96852 }
96853
96854
96855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96856   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96857   Dali::Toolkit::GaussianBlurView arg2 ;
96858   Dali::Toolkit::GaussianBlurView *argp2 ;
96859
96860   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96861   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96862   if (!argp2) {
96863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96864     return ;
96865   }
96866   arg2 = *argp2;
96867   {
96868     try {
96869       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96870     } catch (std::out_of_range& e) {
96871       {
96872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96873       };
96874     } catch (std::exception& e) {
96875       {
96876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96877       };
96878     } catch (Dali::DaliException e) {
96879       {
96880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96881       };
96882     } catch (...) {
96883       {
96884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96885       };
96886     }
96887   }
96888
96889 }
96890
96891
96892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96893   void * jresult ;
96894   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96895
96896   {
96897     try {
96898       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96899     } catch (std::out_of_range& e) {
96900       {
96901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96902       };
96903     } catch (std::exception& e) {
96904       {
96905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96906       };
96907     } catch (Dali::DaliException e) {
96908       {
96909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96910       };
96911     } catch (...) {
96912       {
96913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96914       };
96915     }
96916   }
96917
96918   jresult = (void *)result;
96919   return jresult;
96920 }
96921
96922
96923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96924   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96925
96926   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96927   {
96928     try {
96929       delete arg1;
96930     } catch (std::out_of_range& e) {
96931       {
96932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (std::exception& e) {
96935       {
96936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96937       };
96938     } catch (Dali::DaliException e) {
96939       {
96940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96941       };
96942     } catch (...) {
96943       {
96944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96945       };
96946     }
96947   }
96948
96949 }
96950
96951
96952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96953   unsigned int jresult ;
96954   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96955   bool result;
96956
96957   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96958   {
96959     try {
96960       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);
96961     } catch (std::out_of_range& e) {
96962       {
96963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96964       };
96965     } catch (std::exception& e) {
96966       {
96967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96968       };
96969     } catch (Dali::DaliException e) {
96970       {
96971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96972       };
96973     } catch (...) {
96974       {
96975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96976       };
96977     }
96978   }
96979
96980   jresult = result;
96981   return jresult;
96982 }
96983
96984
96985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96986   unsigned long jresult ;
96987   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96988   std::size_t result;
96989
96990   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96991   {
96992     try {
96993       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);
96994     } catch (std::out_of_range& e) {
96995       {
96996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96997       };
96998     } catch (std::exception& e) {
96999       {
97000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97001       };
97002     } catch (Dali::DaliException e) {
97003       {
97004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97005       };
97006     } catch (...) {
97007       {
97008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97009       };
97010     }
97011   }
97012
97013   jresult = (unsigned long)result;
97014   return jresult;
97015 }
97016
97017
97018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97019   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97020   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97021
97022   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97023   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97024   {
97025     try {
97026       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97027     } catch (std::out_of_range& e) {
97028       {
97029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97030       };
97031     } catch (std::exception& e) {
97032       {
97033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97034       };
97035     } catch (Dali::DaliException e) {
97036       {
97037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97038       };
97039     } catch (...) {
97040       {
97041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97042       };
97043     }
97044   }
97045
97046 }
97047
97048
97049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97050   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97051   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97052
97053   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97054   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97055   {
97056     try {
97057       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97058     } catch (std::out_of_range& e) {
97059       {
97060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97061       };
97062     } catch (std::exception& e) {
97063       {
97064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97065       };
97066     } catch (Dali::DaliException e) {
97067       {
97068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97069       };
97070     } catch (...) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97073       };
97074     }
97075   }
97076
97077 }
97078
97079
97080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97081   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97082   Dali::Toolkit::PageTurnView arg2 ;
97083   unsigned int arg3 ;
97084   bool arg4 ;
97085   Dali::Toolkit::PageTurnView *argp2 ;
97086
97087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97088   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97089   if (!argp2) {
97090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97091     return ;
97092   }
97093   arg2 = *argp2;
97094   arg3 = (unsigned int)jarg3;
97095   arg4 = jarg4 ? true : false;
97096   {
97097     try {
97098       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97099     } catch (std::out_of_range& e) {
97100       {
97101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97102       };
97103     } catch (std::exception& e) {
97104       {
97105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (Dali::DaliException e) {
97108       {
97109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97110       };
97111     } catch (...) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97114       };
97115     }
97116   }
97117
97118 }
97119
97120
97121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97122   void * jresult ;
97123   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97124
97125   {
97126     try {
97127       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97128     } catch (std::out_of_range& e) {
97129       {
97130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97131       };
97132     } catch (std::exception& e) {
97133       {
97134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97135       };
97136     } catch (Dali::DaliException e) {
97137       {
97138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97139       };
97140     } catch (...) {
97141       {
97142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97143       };
97144     }
97145   }
97146
97147   jresult = (void *)result;
97148   return jresult;
97149 }
97150
97151
97152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97153   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97154
97155   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97156   {
97157     try {
97158       delete arg1;
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (Dali::DaliException e) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97170       };
97171     } catch (...) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97174       };
97175     }
97176   }
97177
97178 }
97179
97180
97181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97182   unsigned int jresult ;
97183   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97184   bool result;
97185
97186   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97187   {
97188     try {
97189       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97190     } catch (std::out_of_range& e) {
97191       {
97192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97193       };
97194     } catch (std::exception& e) {
97195       {
97196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97197       };
97198     } catch (Dali::DaliException e) {
97199       {
97200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97201       };
97202     } catch (...) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97205       };
97206     }
97207   }
97208
97209   jresult = result;
97210   return jresult;
97211 }
97212
97213
97214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97215   unsigned long jresult ;
97216   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97217   std::size_t result;
97218
97219   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97220   {
97221     try {
97222       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97230       };
97231     } catch (Dali::DaliException e) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97234       };
97235     } catch (...) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97238       };
97239     }
97240   }
97241
97242   jresult = (unsigned long)result;
97243   return jresult;
97244 }
97245
97246
97247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97248   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97249   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97250
97251   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97252   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97253   {
97254     try {
97255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97256     } catch (std::out_of_range& e) {
97257       {
97258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97259       };
97260     } catch (std::exception& e) {
97261       {
97262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97263       };
97264     } catch (Dali::DaliException e) {
97265       {
97266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97267       };
97268     } catch (...) {
97269       {
97270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97271       };
97272     }
97273   }
97274
97275 }
97276
97277
97278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97279   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97280   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97281
97282   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97283   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97284   {
97285     try {
97286       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97287     } catch (std::out_of_range& e) {
97288       {
97289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97290       };
97291     } catch (std::exception& e) {
97292       {
97293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97294       };
97295     } catch (Dali::DaliException e) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97298       };
97299     } catch (...) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97302       };
97303     }
97304   }
97305
97306 }
97307
97308
97309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97310   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97311   Dali::Toolkit::PageTurnView arg2 ;
97312   Dali::Toolkit::PageTurnView *argp2 ;
97313
97314   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97315   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97316   if (!argp2) {
97317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97318     return ;
97319   }
97320   arg2 = *argp2;
97321   {
97322     try {
97323       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97324     } catch (std::out_of_range& e) {
97325       {
97326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97327       };
97328     } catch (std::exception& e) {
97329       {
97330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97331       };
97332     } catch (Dali::DaliException e) {
97333       {
97334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97335       };
97336     } catch (...) {
97337       {
97338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97339       };
97340     }
97341   }
97342
97343 }
97344
97345
97346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97347   void * jresult ;
97348   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97349
97350   {
97351     try {
97352       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97353     } catch (std::out_of_range& e) {
97354       {
97355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97356       };
97357     } catch (std::exception& e) {
97358       {
97359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97360       };
97361     } catch (Dali::DaliException e) {
97362       {
97363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97364       };
97365     } catch (...) {
97366       {
97367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97368       };
97369     }
97370   }
97371
97372   jresult = (void *)result;
97373   return jresult;
97374 }
97375
97376
97377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97378   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97379
97380   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97381   {
97382     try {
97383       delete arg1;
97384     } catch (std::out_of_range& e) {
97385       {
97386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97387       };
97388     } catch (std::exception& e) {
97389       {
97390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97391       };
97392     } catch (Dali::DaliException e) {
97393       {
97394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97395       };
97396     } catch (...) {
97397       {
97398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97399       };
97400     }
97401   }
97402
97403 }
97404
97405
97406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97407   unsigned int jresult ;
97408   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97409   bool result;
97410
97411   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97412   {
97413     try {
97414       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);
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97430       };
97431     }
97432   }
97433
97434   jresult = result;
97435   return jresult;
97436 }
97437
97438
97439 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97440   unsigned long jresult ;
97441   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97442   std::size_t result;
97443
97444   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97445   {
97446     try {
97447       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);
97448     } catch (std::out_of_range& e) {
97449       {
97450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97451       };
97452     } catch (std::exception& e) {
97453       {
97454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97455       };
97456     } catch (Dali::DaliException e) {
97457       {
97458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97459       };
97460     } catch (...) {
97461       {
97462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97463       };
97464     }
97465   }
97466
97467   jresult = (unsigned long)result;
97468   return jresult;
97469 }
97470
97471
97472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97473   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97474   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97475
97476   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97477   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97478   {
97479     try {
97480       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97481     } catch (std::out_of_range& e) {
97482       {
97483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97484       };
97485     } catch (std::exception& e) {
97486       {
97487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97488       };
97489     } catch (Dali::DaliException e) {
97490       {
97491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97492       };
97493     } catch (...) {
97494       {
97495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97496       };
97497     }
97498   }
97499
97500 }
97501
97502
97503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97504   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97505   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97506
97507   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97508   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97509   {
97510     try {
97511       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97512     } catch (std::out_of_range& e) {
97513       {
97514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97515       };
97516     } catch (std::exception& e) {
97517       {
97518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97519       };
97520     } catch (Dali::DaliException e) {
97521       {
97522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97523       };
97524     } catch (...) {
97525       {
97526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97527       };
97528     }
97529   }
97530
97531 }
97532
97533
97534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97535   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97536   Dali::Toolkit::ProgressBar arg2 ;
97537   float arg3 ;
97538   float arg4 ;
97539   Dali::Toolkit::ProgressBar *argp2 ;
97540
97541   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97542   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97543   if (!argp2) {
97544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97545     return ;
97546   }
97547   arg2 = *argp2;
97548   arg3 = (float)jarg3;
97549   arg4 = (float)jarg4;
97550   {
97551     try {
97552       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97553     } catch (std::out_of_range& e) {
97554       {
97555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97556       };
97557     } catch (std::exception& e) {
97558       {
97559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97560       };
97561     } catch (Dali::DaliException e) {
97562       {
97563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97564       };
97565     } catch (...) {
97566       {
97567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97568       };
97569     }
97570   }
97571
97572 }
97573
97574
97575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97576   void * jresult ;
97577   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97578
97579   {
97580     try {
97581       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97582     } catch (std::out_of_range& e) {
97583       {
97584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97585       };
97586     } catch (std::exception& e) {
97587       {
97588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97589       };
97590     } catch (Dali::DaliException e) {
97591       {
97592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97593       };
97594     } catch (...) {
97595       {
97596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97597       };
97598     }
97599   }
97600
97601   jresult = (void *)result;
97602   return jresult;
97603 }
97604
97605
97606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97607   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97608
97609   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97610   {
97611     try {
97612       delete arg1;
97613     } catch (std::out_of_range& e) {
97614       {
97615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97616       };
97617     } catch (std::exception& e) {
97618       {
97619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97620       };
97621     } catch (Dali::DaliException e) {
97622       {
97623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97624       };
97625     } catch (...) {
97626       {
97627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97628       };
97629     }
97630   }
97631
97632 }
97633
97634
97635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97636   unsigned int jresult ;
97637   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97638   bool result;
97639
97640   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97641   {
97642     try {
97643       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);
97644     } catch (std::out_of_range& e) {
97645       {
97646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97647       };
97648     } catch (std::exception& e) {
97649       {
97650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97651       };
97652     } catch (Dali::DaliException e) {
97653       {
97654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97655       };
97656     } catch (...) {
97657       {
97658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97659       };
97660     }
97661   }
97662
97663   jresult = result;
97664   return jresult;
97665 }
97666
97667
97668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97669   unsigned long jresult ;
97670   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97671   std::size_t result;
97672
97673   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97674   {
97675     try {
97676       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);
97677     } catch (std::out_of_range& e) {
97678       {
97679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97680       };
97681     } catch (std::exception& e) {
97682       {
97683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97684       };
97685     } catch (Dali::DaliException e) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97692       };
97693     }
97694   }
97695
97696   jresult = (unsigned long)result;
97697   return jresult;
97698 }
97699
97700
97701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97702   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97703   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97704
97705   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97706   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97707   {
97708     try {
97709       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97710     } catch (std::out_of_range& e) {
97711       {
97712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97713       };
97714     } catch (std::exception& e) {
97715       {
97716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97717       };
97718     } catch (Dali::DaliException e) {
97719       {
97720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97721       };
97722     } catch (...) {
97723       {
97724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97725       };
97726     }
97727   }
97728
97729 }
97730
97731
97732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97733   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97734   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97735
97736   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97737   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97738   {
97739     try {
97740       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97741     } catch (std::out_of_range& e) {
97742       {
97743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97744       };
97745     } catch (std::exception& e) {
97746       {
97747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97748       };
97749     } catch (Dali::DaliException e) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97752       };
97753     } catch (...) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97756       };
97757     }
97758   }
97759
97760 }
97761
97762
97763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97764   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97765   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97766
97767   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97768   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97769   if (!arg2) {
97770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97771     return ;
97772   }
97773   {
97774     try {
97775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97776     } catch (std::out_of_range& e) {
97777       {
97778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97779       };
97780     } catch (std::exception& e) {
97781       {
97782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97783       };
97784     } catch (Dali::DaliException e) {
97785       {
97786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97787       };
97788     } catch (...) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97791       };
97792     }
97793   }
97794
97795 }
97796
97797
97798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97799   void * jresult ;
97800   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97801
97802   {
97803     try {
97804       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97805     } catch (std::out_of_range& e) {
97806       {
97807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (std::exception& e) {
97810       {
97811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97812       };
97813     } catch (Dali::DaliException e) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97816       };
97817     } catch (...) {
97818       {
97819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97820       };
97821     }
97822   }
97823
97824   jresult = (void *)result;
97825   return jresult;
97826 }
97827
97828
97829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97830   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97831
97832   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97833   {
97834     try {
97835       delete arg1;
97836     } catch (std::out_of_range& e) {
97837       {
97838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97839       };
97840     } catch (std::exception& e) {
97841       {
97842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97843       };
97844     } catch (Dali::DaliException e) {
97845       {
97846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97847       };
97848     } catch (...) {
97849       {
97850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97851       };
97852     }
97853   }
97854
97855 }
97856
97857
97858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97859   unsigned int jresult ;
97860   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97861   bool result;
97862
97863   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97864   {
97865     try {
97866       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97867     } catch (std::out_of_range& e) {
97868       {
97869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97870       };
97871     } catch (std::exception& e) {
97872       {
97873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97874       };
97875     } catch (Dali::DaliException e) {
97876       {
97877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97878       };
97879     } catch (...) {
97880       {
97881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97882       };
97883     }
97884   }
97885
97886   jresult = result;
97887   return jresult;
97888 }
97889
97890
97891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97892   unsigned long jresult ;
97893   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97894   std::size_t result;
97895
97896   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97897   {
97898     try {
97899       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97900     } catch (std::out_of_range& e) {
97901       {
97902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97903       };
97904     } catch (std::exception& e) {
97905       {
97906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97907       };
97908     } catch (Dali::DaliException e) {
97909       {
97910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97911       };
97912     } catch (...) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97915       };
97916     }
97917   }
97918
97919   jresult = (unsigned long)result;
97920   return jresult;
97921 }
97922
97923
97924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97925   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97926   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97927
97928   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97929   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97930   {
97931     try {
97932       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97933     } catch (std::out_of_range& e) {
97934       {
97935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97936       };
97937     } catch (std::exception& e) {
97938       {
97939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97940       };
97941     } catch (Dali::DaliException e) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97944       };
97945     } catch (...) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97948       };
97949     }
97950   }
97951
97952 }
97953
97954
97955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97956   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97957   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97958
97959   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97960   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97961   {
97962     try {
97963       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97964     } catch (std::out_of_range& e) {
97965       {
97966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97967       };
97968     } catch (std::exception& e) {
97969       {
97970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97971       };
97972     } catch (Dali::DaliException e) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97975       };
97976     } catch (...) {
97977       {
97978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97979       };
97980     }
97981   }
97982
97983 }
97984
97985
97986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97987   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97988   Dali::Vector2 *arg2 = 0 ;
97989
97990   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97991   arg2 = (Dali::Vector2 *)jarg2;
97992   if (!arg2) {
97993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97994     return ;
97995   }
97996   {
97997     try {
97998       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97999     } catch (std::out_of_range& e) {
98000       {
98001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98002       };
98003     } catch (std::exception& e) {
98004       {
98005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98006       };
98007     } catch (Dali::DaliException e) {
98008       {
98009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98010       };
98011     } catch (...) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98014       };
98015     }
98016   }
98017
98018 }
98019
98020
98021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98022   void * jresult ;
98023   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98024
98025   {
98026     try {
98027       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98028     } catch (std::out_of_range& e) {
98029       {
98030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98031       };
98032     } catch (std::exception& e) {
98033       {
98034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98035       };
98036     } catch (Dali::DaliException e) {
98037       {
98038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98039       };
98040     } catch (...) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98043       };
98044     }
98045   }
98046
98047   jresult = (void *)result;
98048   return jresult;
98049 }
98050
98051
98052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98053   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98054
98055   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98056   {
98057     try {
98058       delete arg1;
98059     } catch (std::out_of_range& e) {
98060       {
98061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98062       };
98063     } catch (std::exception& e) {
98064       {
98065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98066       };
98067     } catch (Dali::DaliException e) {
98068       {
98069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98070       };
98071     } catch (...) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98074       };
98075     }
98076   }
98077
98078 }
98079
98080
98081
98082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98083   unsigned int jresult ;
98084   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98085   bool result;
98086
98087   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98088   {
98089     try {
98090       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);
98091     } catch (std::out_of_range& e) {
98092       {
98093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98094       };
98095     } catch (std::exception& e) {
98096       {
98097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98098       };
98099     } catch (Dali::DaliException e) {
98100       {
98101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98102       };
98103     } catch (...) {
98104       {
98105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98106       };
98107     }
98108   }
98109
98110   jresult = result;
98111   return jresult;
98112 }
98113
98114
98115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98116   unsigned long jresult ;
98117   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98118   std::size_t result;
98119
98120   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98121   {
98122     try {
98123       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);
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 (Dali::DaliException e) {
98133       {
98134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98135       };
98136     } catch (...) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98139       };
98140     }
98141   }
98142
98143   jresult = (unsigned long)result;
98144   return jresult;
98145 }
98146
98147
98148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98149   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98150   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98151
98152   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98153   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98154   {
98155     try {
98156       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98157     } catch (std::out_of_range& e) {
98158       {
98159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98160       };
98161     } catch (std::exception& e) {
98162       {
98163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98164       };
98165     } catch (Dali::DaliException e) {
98166       {
98167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98168       };
98169     } catch (...) {
98170       {
98171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98172       };
98173     }
98174   }
98175
98176 }
98177
98178
98179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98180   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98181   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98182
98183   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98184   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98185   {
98186     try {
98187       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98188     } catch (std::out_of_range& e) {
98189       {
98190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98191       };
98192     } catch (std::exception& e) {
98193       {
98194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98195       };
98196     } catch (Dali::DaliException e) {
98197       {
98198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98199       };
98200     } catch (...) {
98201       {
98202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98203       };
98204     }
98205   }
98206
98207 }
98208
98209
98210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98211   unsigned int jresult ;
98212   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98213   Dali::Toolkit::Control arg2 ;
98214   Dali::KeyEvent *arg3 = 0 ;
98215   Dali::Toolkit::Control *argp2 ;
98216   bool result;
98217
98218   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98219   argp2 = (Dali::Toolkit::Control *)jarg2;
98220   if (!argp2) {
98221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98222     return 0;
98223   }
98224   arg2 = *argp2;
98225   arg3 = (Dali::KeyEvent *)jarg3;
98226   if (!arg3) {
98227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98228     return 0;
98229   }
98230   {
98231     try {
98232       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);
98233     } catch (std::out_of_range& e) {
98234       {
98235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98236       };
98237     } catch (std::exception& e) {
98238       {
98239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98240       };
98241     } catch (Dali::DaliException e) {
98242       {
98243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98244       };
98245     } catch (...) {
98246       {
98247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98248       };
98249     }
98250   }
98251
98252   jresult = result;
98253   return jresult;
98254 }
98255
98256
98257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98258   void * jresult ;
98259   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98260
98261   {
98262     try {
98263       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98264     } catch (std::out_of_range& e) {
98265       {
98266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98267       };
98268     } catch (std::exception& e) {
98269       {
98270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98271       };
98272     } catch (Dali::DaliException e) {
98273       {
98274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98275       };
98276     } catch (...) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98279       };
98280     }
98281   }
98282
98283   jresult = (void *)result;
98284   return jresult;
98285 }
98286
98287
98288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98289   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98290
98291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98292   {
98293     try {
98294       delete arg1;
98295     } catch (std::out_of_range& e) {
98296       {
98297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98298       };
98299     } catch (std::exception& e) {
98300       {
98301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98302       };
98303     } catch (Dali::DaliException e) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98306       };
98307     } catch (...) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98310       };
98311     }
98312   }
98313
98314 }
98315
98316
98317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98318   unsigned int jresult ;
98319   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98320   bool result;
98321
98322   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98323   {
98324     try {
98325       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98326     } catch (std::out_of_range& e) {
98327       {
98328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98329       };
98330     } catch (std::exception& e) {
98331       {
98332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98333       };
98334     } catch (Dali::DaliException e) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98337       };
98338     } catch (...) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98341       };
98342     }
98343   }
98344
98345   jresult = result;
98346   return jresult;
98347 }
98348
98349
98350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98351   unsigned long jresult ;
98352   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98353   std::size_t result;
98354
98355   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98356   {
98357     try {
98358       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98359     } catch (std::out_of_range& e) {
98360       {
98361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98362       };
98363     } catch (std::exception& e) {
98364       {
98365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98366       };
98367     } catch (Dali::DaliException e) {
98368       {
98369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98370       };
98371     } catch (...) {
98372       {
98373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98374       };
98375     }
98376   }
98377
98378   jresult = (unsigned long)result;
98379   return jresult;
98380 }
98381
98382
98383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98384   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98385   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98386
98387   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98388   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98389   {
98390     try {
98391       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98392     } catch (std::out_of_range& e) {
98393       {
98394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98395       };
98396     } catch (std::exception& e) {
98397       {
98398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98399       };
98400     } catch (Dali::DaliException e) {
98401       {
98402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98403       };
98404     } catch (...) {
98405       {
98406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98407       };
98408     }
98409   }
98410
98411 }
98412
98413
98414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98415   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98416   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98417
98418   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98419   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98420   {
98421     try {
98422       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98423     } catch (std::out_of_range& e) {
98424       {
98425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98426       };
98427     } catch (std::exception& e) {
98428       {
98429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98430       };
98431     } catch (Dali::DaliException e) {
98432       {
98433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98434       };
98435     } catch (...) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98438       };
98439     }
98440   }
98441
98442 }
98443
98444
98445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98446   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98447   Dali::Toolkit::Control arg2 ;
98448   Dali::Toolkit::Control *argp2 ;
98449
98450   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98451   argp2 = (Dali::Toolkit::Control *)jarg2;
98452   if (!argp2) {
98453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98454     return ;
98455   }
98456   arg2 = *argp2;
98457   {
98458     try {
98459       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98460     } catch (std::out_of_range& e) {
98461       {
98462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98463       };
98464     } catch (std::exception& e) {
98465       {
98466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (Dali::DaliException e) {
98469       {
98470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98471       };
98472     } catch (...) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98475       };
98476     }
98477   }
98478
98479 }
98480
98481
98482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98483   void * jresult ;
98484   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98485
98486   {
98487     try {
98488       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98489     } catch (std::out_of_range& e) {
98490       {
98491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98492       };
98493     } catch (std::exception& e) {
98494       {
98495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98496       };
98497     } catch (Dali::DaliException e) {
98498       {
98499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98500       };
98501     } catch (...) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98504       };
98505     }
98506   }
98507
98508   jresult = (void *)result;
98509   return jresult;
98510 }
98511
98512
98513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98514   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98515
98516   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98517   {
98518     try {
98519       delete arg1;
98520     } catch (std::out_of_range& e) {
98521       {
98522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (std::exception& e) {
98525       {
98526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (Dali::DaliException e) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98531       };
98532     } catch (...) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98535       };
98536     }
98537   }
98538
98539 }
98540
98541
98542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98543   unsigned int jresult ;
98544   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98545   bool result;
98546
98547   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98548   {
98549     try {
98550       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98551     } catch (std::out_of_range& e) {
98552       {
98553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98554       };
98555     } catch (std::exception& e) {
98556       {
98557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98558       };
98559     } catch (Dali::DaliException e) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98562       };
98563     } catch (...) {
98564       {
98565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98566       };
98567     }
98568   }
98569
98570   jresult = result;
98571   return jresult;
98572 }
98573
98574
98575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98576   unsigned long jresult ;
98577   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98578   std::size_t result;
98579
98580   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98581   {
98582     try {
98583       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98584     } catch (std::out_of_range& e) {
98585       {
98586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98587       };
98588     } catch (std::exception& e) {
98589       {
98590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98591       };
98592     } catch (Dali::DaliException e) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98595       };
98596     } catch (...) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98599       };
98600     }
98601   }
98602
98603   jresult = (unsigned long)result;
98604   return jresult;
98605 }
98606
98607
98608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98609   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98610   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98611
98612   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98613   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98614   {
98615     try {
98616       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98617     } catch (std::out_of_range& e) {
98618       {
98619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98620       };
98621     } catch (std::exception& e) {
98622       {
98623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98624       };
98625     } catch (Dali::DaliException e) {
98626       {
98627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98628       };
98629     } catch (...) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98632       };
98633     }
98634   }
98635
98636 }
98637
98638
98639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98640   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98641   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98642
98643   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98644   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98645   {
98646     try {
98647       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98648     } catch (std::out_of_range& e) {
98649       {
98650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98651       };
98652     } catch (std::exception& e) {
98653       {
98654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98655       };
98656     } catch (Dali::DaliException e) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98659       };
98660     } catch (...) {
98661       {
98662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98663       };
98664     }
98665   }
98666
98667 }
98668
98669
98670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98671   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98672   Dali::Toolkit::VideoView *arg2 = 0 ;
98673
98674   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98675   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98676   if (!arg2) {
98677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98678     return ;
98679   }
98680   {
98681     try {
98682       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98683     } catch (std::out_of_range& e) {
98684       {
98685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98686       };
98687     } catch (std::exception& e) {
98688       {
98689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98690       };
98691     } catch (Dali::DaliException e) {
98692       {
98693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98694       };
98695     } catch (...) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98698       };
98699     }
98700   }
98701
98702 }
98703
98704
98705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98706   void * jresult ;
98707   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98708
98709   {
98710     try {
98711       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98712     } catch (std::out_of_range& e) {
98713       {
98714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98715       };
98716     } catch (std::exception& e) {
98717       {
98718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98719       };
98720     } catch (Dali::DaliException e) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98723       };
98724     } catch (...) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98727       };
98728     }
98729   }
98730
98731   jresult = (void *)result;
98732   return jresult;
98733 }
98734
98735
98736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98737   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98738
98739   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98740   {
98741     try {
98742       delete arg1;
98743     } catch (std::out_of_range& e) {
98744       {
98745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98746       };
98747     } catch (std::exception& e) {
98748       {
98749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98750       };
98751     } catch (Dali::DaliException e) {
98752       {
98753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98754       };
98755     } catch (...) {
98756       {
98757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98758       };
98759     }
98760   }
98761
98762 }
98763
98764
98765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98766   unsigned int jresult ;
98767   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98768   bool result;
98769
98770   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98771   {
98772     try {
98773       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98774     } catch (std::out_of_range& e) {
98775       {
98776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98777       };
98778     } catch (std::exception& e) {
98779       {
98780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98781       };
98782     } catch (Dali::DaliException e) {
98783       {
98784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98785       };
98786     } catch (...) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98789       };
98790     }
98791   }
98792
98793   jresult = result;
98794   return jresult;
98795 }
98796
98797
98798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98799   unsigned long jresult ;
98800   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98801   std::size_t result;
98802
98803   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98804   {
98805     try {
98806       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98807     } catch (std::out_of_range& e) {
98808       {
98809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98810       };
98811     } catch (std::exception& e) {
98812       {
98813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98814       };
98815     } catch (Dali::DaliException e) {
98816       {
98817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98818       };
98819     } catch (...) {
98820       {
98821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98822       };
98823     }
98824   }
98825
98826   jresult = (unsigned long)result;
98827   return jresult;
98828 }
98829
98830
98831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98832   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98833   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98834
98835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98836   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98837   {
98838     try {
98839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98840     } catch (std::out_of_range& e) {
98841       {
98842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98843       };
98844     } catch (std::exception& e) {
98845       {
98846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98847       };
98848     } catch (Dali::DaliException e) {
98849       {
98850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98851       };
98852     } catch (...) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98855       };
98856     }
98857   }
98858
98859 }
98860
98861
98862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98863   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98864   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98865
98866   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98867   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98868   {
98869     try {
98870       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98871     } catch (std::out_of_range& e) {
98872       {
98873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98874       };
98875     } catch (std::exception& e) {
98876       {
98877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98878       };
98879     } catch (Dali::DaliException e) {
98880       {
98881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98882       };
98883     } catch (...) {
98884       {
98885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98886       };
98887     }
98888   }
98889
98890 }
98891
98892
98893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98894   unsigned int jresult ;
98895   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98896   Dali::Toolkit::Slider arg2 ;
98897   float arg3 ;
98898   Dali::Toolkit::Slider *argp2 ;
98899   bool result;
98900
98901   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98902   argp2 = (Dali::Toolkit::Slider *)jarg2;
98903   if (!argp2) {
98904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98905     return 0;
98906   }
98907   arg2 = *argp2;
98908   arg3 = (float)jarg3;
98909   {
98910     try {
98911       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98912     } catch (std::out_of_range& e) {
98913       {
98914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98915       };
98916     } catch (std::exception& e) {
98917       {
98918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (Dali::DaliException e) {
98921       {
98922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98923       };
98924     } catch (...) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98927       };
98928     }
98929   }
98930
98931   jresult = result;
98932   return jresult;
98933 }
98934
98935
98936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98937   void * jresult ;
98938   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98939
98940   {
98941     try {
98942       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98943     } catch (std::out_of_range& e) {
98944       {
98945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (std::exception& e) {
98948       {
98949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98950       };
98951     } catch (Dali::DaliException e) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98954       };
98955     } catch (...) {
98956       {
98957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98958       };
98959     }
98960   }
98961
98962   jresult = (void *)result;
98963   return jresult;
98964 }
98965
98966
98967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98968   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98969
98970   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98971   {
98972     try {
98973       delete arg1;
98974     } catch (std::out_of_range& e) {
98975       {
98976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98977       };
98978     } catch (std::exception& e) {
98979       {
98980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98981       };
98982     } catch (Dali::DaliException e) {
98983       {
98984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98985       };
98986     } catch (...) {
98987       {
98988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98989       };
98990     }
98991   }
98992
98993 }
98994
98995
98996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98997   unsigned int jresult ;
98998   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98999   bool result;
99000
99001   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99002   {
99003     try {
99004       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99005     } catch (std::out_of_range& e) {
99006       {
99007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99008       };
99009     } catch (std::exception& e) {
99010       {
99011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (Dali::DaliException e) {
99014       {
99015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99016       };
99017     } catch (...) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99020       };
99021     }
99022   }
99023
99024   jresult = result;
99025   return jresult;
99026 }
99027
99028
99029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99030   unsigned long jresult ;
99031   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99032   std::size_t result;
99033
99034   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99035   {
99036     try {
99037       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99038     } catch (std::out_of_range& e) {
99039       {
99040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99041       };
99042     } catch (std::exception& e) {
99043       {
99044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99045       };
99046     } catch (Dali::DaliException e) {
99047       {
99048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99049       };
99050     } catch (...) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99053       };
99054     }
99055   }
99056
99057   jresult = (unsigned long)result;
99058   return jresult;
99059 }
99060
99061
99062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99063   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99064   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99065
99066   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99067   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99068   {
99069     try {
99070       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99071     } catch (std::out_of_range& e) {
99072       {
99073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99074       };
99075     } catch (std::exception& e) {
99076       {
99077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99078       };
99079     } catch (Dali::DaliException e) {
99080       {
99081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99082       };
99083     } catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99086       };
99087     }
99088   }
99089
99090 }
99091
99092
99093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99094   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99095   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99096
99097   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99098   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99099   {
99100     try {
99101       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99102     } catch (std::out_of_range& e) {
99103       {
99104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99105       };
99106     } catch (std::exception& e) {
99107       {
99108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99109       };
99110     } catch (Dali::DaliException e) {
99111       {
99112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99113       };
99114     } catch (...) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99117       };
99118     }
99119   }
99120
99121 }
99122
99123
99124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99125   unsigned int jresult ;
99126   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99127   Dali::Toolkit::Slider arg2 ;
99128   int arg3 ;
99129   Dali::Toolkit::Slider *argp2 ;
99130   bool result;
99131
99132   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99133   argp2 = (Dali::Toolkit::Slider *)jarg2;
99134   if (!argp2) {
99135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99136     return 0;
99137   }
99138   arg2 = *argp2;
99139   arg3 = (int)jarg3;
99140   {
99141     try {
99142       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99143     } catch (std::out_of_range& e) {
99144       {
99145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99146       };
99147     } catch (std::exception& e) {
99148       {
99149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99150       };
99151     } catch (Dali::DaliException e) {
99152       {
99153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99154       };
99155     } catch (...) {
99156       {
99157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99158       };
99159     }
99160   }
99161
99162   jresult = result;
99163   return jresult;
99164 }
99165
99166
99167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99168   void * jresult ;
99169   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99170
99171   {
99172     try {
99173       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99174     } catch (std::out_of_range& e) {
99175       {
99176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99177       };
99178     } catch (std::exception& e) {
99179       {
99180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99181       };
99182     } catch (Dali::DaliException e) {
99183       {
99184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99185       };
99186     } catch (...) {
99187       {
99188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99189       };
99190     }
99191   }
99192
99193   jresult = (void *)result;
99194   return jresult;
99195 }
99196
99197
99198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99199   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99200
99201   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99202   {
99203     try {
99204       delete arg1;
99205     } catch (std::out_of_range& e) {
99206       {
99207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99208       };
99209     } catch (std::exception& e) {
99210       {
99211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99212       };
99213     } catch (Dali::DaliException e) {
99214       {
99215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99216       };
99217     } catch (...) {
99218       {
99219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99220       };
99221     }
99222   }
99223
99224 }
99225
99226
99227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99228   void * jresult ;
99229   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99230
99231   {
99232     try {
99233       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99234     } catch (std::out_of_range& e) {
99235       {
99236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99237       };
99238     } catch (std::exception& e) {
99239       {
99240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99241       };
99242     } catch (Dali::DaliException e) {
99243       {
99244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99245       };
99246     } catch (...) {
99247       {
99248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99249       };
99250     }
99251   }
99252
99253   jresult = (void *)result;
99254   return jresult;
99255 }
99256
99257
99258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99259   void * jresult ;
99260   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99261   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99262
99263   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99264   {
99265     try {
99266       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99267     } catch (std::out_of_range& e) {
99268       {
99269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99270       };
99271     } catch (std::exception& e) {
99272       {
99273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (Dali::DaliException e) {
99276       {
99277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99278       };
99279     } catch (...) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99282       };
99283     }
99284   }
99285
99286   jresult = (void *)result;
99287   return jresult;
99288 }
99289
99290
99291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99292   void * jresult ;
99293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99295
99296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99297   if (!arg1) {
99298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99299     return 0;
99300   }
99301   {
99302     try {
99303       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99304     } catch (std::out_of_range& e) {
99305       {
99306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99307       };
99308     } catch (std::exception& e) {
99309       {
99310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99311       };
99312     } catch (Dali::DaliException e) {
99313       {
99314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99315       };
99316     } catch (...) {
99317       {
99318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99319       };
99320     }
99321   }
99322
99323   jresult = (void *)result;
99324   return jresult;
99325 }
99326
99327
99328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99329   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99330
99331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99332   {
99333     try {
99334       delete arg1;
99335     } catch (std::out_of_range& e) {
99336       {
99337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99338       };
99339     } catch (std::exception& e) {
99340       {
99341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99342       };
99343     } catch (Dali::DaliException e) {
99344       {
99345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99346       };
99347     } catch (...) {
99348       {
99349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99350       };
99351     }
99352   }
99353
99354 }
99355
99356
99357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99358   void * jresult ;
99359   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99360   Dali::Toolkit::Ruler *result = 0 ;
99361
99362   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99363   {
99364     try {
99365       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99366     } catch (std::out_of_range& e) {
99367       {
99368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99369       };
99370     } catch (std::exception& e) {
99371       {
99372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99373       };
99374     } catch (Dali::DaliException e) {
99375       {
99376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99377       };
99378     } catch (...) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99381       };
99382     }
99383   }
99384
99385   jresult = (void *)result;
99386   return jresult;
99387 }
99388
99389
99390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99391   void * jresult ;
99392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99393   Dali::Toolkit::Ruler *result = 0 ;
99394
99395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99396   {
99397     try {
99398       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99399     } catch (std::out_of_range& e) {
99400       {
99401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99402       };
99403     } catch (std::exception& e) {
99404       {
99405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99406       };
99407     } catch (Dali::DaliException e) {
99408       {
99409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99410       };
99411     } catch (...) {
99412       {
99413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99414       };
99415     }
99416   }
99417
99418   jresult = (void *)result;
99419   return jresult;
99420 }
99421
99422
99423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99424   void * jresult ;
99425   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99426   Dali::Toolkit::Ruler *result = 0 ;
99427
99428   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99429   {
99430     try {
99431       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99432     } catch (std::out_of_range& e) {
99433       {
99434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99435       };
99436     } catch (std::exception& e) {
99437       {
99438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99439       };
99440     } catch (Dali::DaliException e) {
99441       {
99442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99443       };
99444     } catch (...) {
99445       {
99446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99447       };
99448     }
99449   }
99450
99451   jresult = (void *)result;
99452   return jresult;
99453 }
99454
99455
99456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99457   void * jresult ;
99458   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99459   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99460   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99461
99462   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99463   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99464   if (!arg2) {
99465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99466     return 0;
99467   }
99468   {
99469     try {
99470       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99471     } catch (std::out_of_range& e) {
99472       {
99473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99474       };
99475     } catch (std::exception& e) {
99476       {
99477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (Dali::DaliException e) {
99480       {
99481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99482       };
99483     } catch (...) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99486       };
99487     }
99488   }
99489
99490   jresult = (void *)result;
99491   return jresult;
99492 }
99493
99494
99495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99496   void * jresult ;
99497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99498   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99500
99501   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99502   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99503   {
99504     try {
99505       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99506     } catch (std::out_of_range& e) {
99507       {
99508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99509       };
99510     } catch (std::exception& e) {
99511       {
99512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99513       };
99514     } catch (Dali::DaliException e) {
99515       {
99516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99517       };
99518     } catch (...) {
99519       {
99520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99521       };
99522     }
99523   }
99524
99525   jresult = (void *)result;
99526   return jresult;
99527 }
99528
99529
99530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99531   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99532
99533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99534   {
99535     try {
99536       (arg1)->Reset();
99537     } catch (std::out_of_range& e) {
99538       {
99539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99540       };
99541     } catch (std::exception& e) {
99542       {
99543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99544       };
99545     } catch (Dali::DaliException e) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99548       };
99549     } catch (...) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99552       };
99553     }
99554   }
99555
99556 }
99557
99558
99559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99560   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99561   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99562
99563   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99564   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99565   {
99566     try {
99567       (arg1)->Reset(arg2);
99568     } catch (std::out_of_range& e) {
99569       {
99570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99571       };
99572     } catch (std::exception& e) {
99573       {
99574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99575       };
99576     } catch (Dali::DaliException e) {
99577       {
99578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99579       };
99580     } catch (...) {
99581       {
99582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99583       };
99584     }
99585   }
99586
99587 }
99588
99589
99590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99591   void * jresult ;
99592   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99593   Dali::Toolkit::Ruler *result = 0 ;
99594
99595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99596   {
99597     try {
99598       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99599     } catch (std::out_of_range& e) {
99600       {
99601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99602       };
99603     } catch (std::exception& e) {
99604       {
99605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99606       };
99607     } catch (Dali::DaliException e) {
99608       {
99609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99610       };
99611     } catch (...) {
99612       {
99613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99614       };
99615     }
99616   }
99617
99618   jresult = (void *)result;
99619   return jresult;
99620 }
99621
99622
99623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99624   float jresult ;
99625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99626   float arg2 ;
99627   float arg3 ;
99628   float result;
99629
99630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99631   arg2 = (float)jarg2;
99632   arg3 = (float)jarg3;
99633   {
99634     try {
99635       result = (float)(*arg1)->Snap(arg2,arg3);
99636     } catch (std::out_of_range& e) {
99637       {
99638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99639       };
99640     } catch (std::exception& e) {
99641       {
99642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99643       };
99644     } catch (Dali::DaliException e) {
99645       {
99646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99647       };
99648     } catch (...) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99651       };
99652     }
99653   }
99654
99655   jresult = result;
99656   return jresult;
99657 }
99658
99659
99660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99661   float jresult ;
99662   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99663   float arg2 ;
99664   float result;
99665
99666   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99667   arg2 = (float)jarg2;
99668   {
99669     try {
99670       result = (float)(*arg1)->Snap(arg2);
99671     } catch (std::out_of_range& e) {
99672       {
99673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99674       };
99675     } catch (std::exception& e) {
99676       {
99677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99678       };
99679     } catch (Dali::DaliException e) {
99680       {
99681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99682       };
99683     } catch (...) {
99684       {
99685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99686       };
99687     }
99688   }
99689
99690   jresult = result;
99691   return jresult;
99692 }
99693
99694
99695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99696   float jresult ;
99697   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99698   unsigned int arg2 ;
99699   unsigned int *arg3 = 0 ;
99700   bool arg4 ;
99701   float result;
99702
99703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99704   arg2 = (unsigned int)jarg2;
99705   arg3 = (unsigned int *)jarg3;
99706   arg4 = jarg4 ? true : false;
99707   {
99708     try {
99709       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99710     } catch (std::out_of_range& e) {
99711       {
99712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99713       };
99714     } catch (std::exception& e) {
99715       {
99716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99717       };
99718     } catch (Dali::DaliException e) {
99719       {
99720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99721       };
99722     } catch (...) {
99723       {
99724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99725       };
99726     }
99727   }
99728
99729   jresult = result;
99730   return jresult;
99731 }
99732
99733
99734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99735   unsigned int jresult ;
99736   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99737   float arg2 ;
99738   bool arg3 ;
99739   unsigned int result;
99740
99741   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99742   arg2 = (float)jarg2;
99743   arg3 = jarg3 ? true : false;
99744   {
99745     try {
99746       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99747     } catch (std::out_of_range& e) {
99748       {
99749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99750       };
99751     } catch (std::exception& e) {
99752       {
99753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99754       };
99755     } catch (Dali::DaliException e) {
99756       {
99757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99758       };
99759     } catch (...) {
99760       {
99761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99762       };
99763     }
99764   }
99765
99766   jresult = result;
99767   return jresult;
99768 }
99769
99770
99771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99772   unsigned int jresult ;
99773   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99774   unsigned int result;
99775
99776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99777   {
99778     try {
99779       result = (unsigned int)(*arg1)->GetTotalPages();
99780     } catch (std::out_of_range& e) {
99781       {
99782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99783       };
99784     } catch (std::exception& e) {
99785       {
99786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99787       };
99788     } catch (Dali::DaliException e) {
99789       {
99790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99791       };
99792     } catch (...) {
99793       {
99794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99795       };
99796     }
99797   }
99798
99799   jresult = result;
99800   return jresult;
99801 }
99802
99803
99804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99805   int jresult ;
99806   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99807   Dali::Toolkit::Ruler::RulerType result;
99808
99809   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99810   {
99811     try {
99812       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99813     } catch (std::out_of_range& e) {
99814       {
99815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99816       };
99817     } catch (std::exception& e) {
99818       {
99819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99820       };
99821     } catch (Dali::DaliException e) {
99822       {
99823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99824       };
99825     } catch (...) {
99826       {
99827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99828       };
99829     }
99830   }
99831
99832   jresult = (int)result;
99833   return jresult;
99834 }
99835
99836
99837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99838   unsigned int jresult ;
99839   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99840   bool result;
99841
99842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99843   {
99844     try {
99845       result = (bool)(*arg1)->IsEnabled();
99846     } catch (std::out_of_range& e) {
99847       {
99848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99849       };
99850     } catch (std::exception& e) {
99851       {
99852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99853       };
99854     } catch (Dali::DaliException e) {
99855       {
99856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99857       };
99858     } catch (...) {
99859       {
99860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99861       };
99862     }
99863   }
99864
99865   jresult = result;
99866   return jresult;
99867 }
99868
99869
99870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99871   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99872
99873   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99874   {
99875     try {
99876       (*arg1)->Enable();
99877     } catch (std::out_of_range& e) {
99878       {
99879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99880       };
99881     } catch (std::exception& e) {
99882       {
99883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99884       };
99885     } catch (Dali::DaliException e) {
99886       {
99887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99888       };
99889     } catch (...) {
99890       {
99891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99892       };
99893     }
99894   }
99895
99896 }
99897
99898
99899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99900   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99901
99902   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99903   {
99904     try {
99905       (*arg1)->Disable();
99906     } catch (std::out_of_range& e) {
99907       {
99908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99909       };
99910     } catch (std::exception& e) {
99911       {
99912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99913       };
99914     } catch (Dali::DaliException e) {
99915       {
99916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99917       };
99918     } catch (...) {
99919       {
99920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99921       };
99922     }
99923   }
99924
99925 }
99926
99927
99928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99930   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99931   Dali::Toolkit::RulerDomain *argp2 ;
99932
99933   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99934   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99935   if (!argp2) {
99936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99937     return ;
99938   }
99939   arg2 = *argp2;
99940   {
99941     try {
99942       (*arg1)->SetDomain(arg2);
99943     } catch (std::out_of_range& e) {
99944       {
99945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99946       };
99947     } catch (std::exception& e) {
99948       {
99949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99950       };
99951     } catch (Dali::DaliException e) {
99952       {
99953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99954       };
99955     } catch (...) {
99956       {
99957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99958       };
99959     }
99960   }
99961
99962 }
99963
99964
99965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99966   void * jresult ;
99967   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99968   Dali::Toolkit::RulerDomain *result = 0 ;
99969
99970   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99971   {
99972     try {
99973       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99974     } catch (std::out_of_range& e) {
99975       {
99976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99977       };
99978     } catch (std::exception& e) {
99979       {
99980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99981       };
99982     } catch (Dali::DaliException e) {
99983       {
99984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99985       };
99986     } catch (...) {
99987       {
99988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99989       };
99990     }
99991   }
99992
99993   jresult = (void *)result;
99994   return jresult;
99995 }
99996
99997
99998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99999   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100000
100001   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100002   {
100003     try {
100004       (*arg1)->DisableDomain();
100005     } catch (std::out_of_range& e) {
100006       {
100007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100008       };
100009     } catch (std::exception& e) {
100010       {
100011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100012       };
100013     } catch (Dali::DaliException e) {
100014       {
100015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100016       };
100017     } catch (...) {
100018       {
100019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100020       };
100021     }
100022   }
100023
100024 }
100025
100026
100027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100028   float jresult ;
100029   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100030   float arg2 ;
100031   float arg3 ;
100032   float arg4 ;
100033   float result;
100034
100035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100036   arg2 = (float)jarg2;
100037   arg3 = (float)jarg3;
100038   arg4 = (float)jarg4;
100039   {
100040     try {
100041       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100042     } catch (std::out_of_range& e) {
100043       {
100044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100045       };
100046     } catch (std::exception& e) {
100047       {
100048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100049       };
100050     } catch (Dali::DaliException e) {
100051       {
100052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100053       };
100054     } catch (...) {
100055       {
100056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100057       };
100058     }
100059   }
100060
100061   jresult = result;
100062   return jresult;
100063 }
100064
100065
100066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100067   float jresult ;
100068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100069   float arg2 ;
100070   float arg3 ;
100071   float result;
100072
100073   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100074   arg2 = (float)jarg2;
100075   arg3 = (float)jarg3;
100076   {
100077     try {
100078       result = (float)(*arg1)->Clamp(arg2,arg3);
100079     } catch (std::out_of_range& e) {
100080       {
100081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (std::exception& e) {
100084       {
100085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100086       };
100087     } catch (Dali::DaliException e) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100090       };
100091     } catch (...) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100094       };
100095     }
100096   }
100097
100098   jresult = result;
100099   return jresult;
100100 }
100101
100102
100103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100104   float jresult ;
100105   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100106   float arg2 ;
100107   float result;
100108
100109   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100110   arg2 = (float)jarg2;
100111   {
100112     try {
100113       result = (float)(*arg1)->Clamp(arg2);
100114     } catch (std::out_of_range& e) {
100115       {
100116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100117       };
100118     } catch (std::exception& e) {
100119       {
100120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100121       };
100122     } catch (Dali::DaliException e) {
100123       {
100124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100125       };
100126     } catch (...) {
100127       {
100128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100129       };
100130     }
100131   }
100132
100133   jresult = result;
100134   return jresult;
100135 }
100136
100137
100138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100139   float jresult ;
100140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100141   float arg2 ;
100142   float arg3 ;
100143   float arg4 ;
100144   Dali::Toolkit::ClampState *arg5 = 0 ;
100145   float result;
100146
100147   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100148   arg2 = (float)jarg2;
100149   arg3 = (float)jarg3;
100150   arg4 = (float)jarg4;
100151   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100152   if (!arg5) {
100153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100154     return 0;
100155   }
100156   {
100157     try {
100158       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100159     } catch (std::out_of_range& e) {
100160       {
100161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100162       };
100163     } catch (std::exception& e) {
100164       {
100165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100166       };
100167     } catch (Dali::DaliException e) {
100168       {
100169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100170       };
100171     } catch (...) {
100172       {
100173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100174       };
100175     }
100176   }
100177
100178   jresult = result;
100179   return jresult;
100180 }
100181
100182
100183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100184   float jresult ;
100185   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100186   float arg2 ;
100187   float arg3 ;
100188   float arg4 ;
100189   float arg5 ;
100190   float result;
100191
100192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100193   arg2 = (float)jarg2;
100194   arg3 = (float)jarg3;
100195   arg4 = (float)jarg4;
100196   arg5 = (float)jarg5;
100197   {
100198     try {
100199       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100200     } catch (std::out_of_range& e) {
100201       {
100202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100203       };
100204     } catch (std::exception& e) {
100205       {
100206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100207       };
100208     } catch (Dali::DaliException e) {
100209       {
100210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100211       };
100212     } catch (...) {
100213       {
100214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100215       };
100216     }
100217   }
100218
100219   jresult = result;
100220   return jresult;
100221 }
100222
100223
100224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100225   float jresult ;
100226   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100227   float arg2 ;
100228   float arg3 ;
100229   float arg4 ;
100230   float result;
100231
100232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100233   arg2 = (float)jarg2;
100234   arg3 = (float)jarg3;
100235   arg4 = (float)jarg4;
100236   {
100237     try {
100238       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100239     } catch (std::out_of_range& e) {
100240       {
100241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100242       };
100243     } catch (std::exception& e) {
100244       {
100245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100246       };
100247     } catch (Dali::DaliException e) {
100248       {
100249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100250       };
100251     } catch (...) {
100252       {
100253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100254       };
100255     }
100256   }
100257
100258   jresult = result;
100259   return jresult;
100260 }
100261
100262
100263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100264   float jresult ;
100265   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100266   float arg2 ;
100267   float arg3 ;
100268   float result;
100269
100270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100271   arg2 = (float)jarg2;
100272   arg3 = (float)jarg3;
100273   {
100274     try {
100275       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100276     } catch (std::out_of_range& e) {
100277       {
100278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100279       };
100280     } catch (std::exception& e) {
100281       {
100282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100283       };
100284     } catch (Dali::DaliException e) {
100285       {
100286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100287       };
100288     } catch (...) {
100289       {
100290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100291       };
100292     }
100293   }
100294
100295   jresult = result;
100296   return jresult;
100297 }
100298
100299
100300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100301   float jresult ;
100302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100303   float arg2 ;
100304   float result;
100305
100306   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100307   arg2 = (float)jarg2;
100308   {
100309     try {
100310       result = (float)(*arg1)->SnapAndClamp(arg2);
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100326       };
100327     }
100328   }
100329
100330   jresult = result;
100331   return jresult;
100332 }
100333
100334
100335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100336   float jresult ;
100337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100338   float arg2 ;
100339   float arg3 ;
100340   float arg4 ;
100341   float arg5 ;
100342   Dali::Toolkit::ClampState *arg6 = 0 ;
100343   float result;
100344
100345   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100346   arg2 = (float)jarg2;
100347   arg3 = (float)jarg3;
100348   arg4 = (float)jarg4;
100349   arg5 = (float)jarg5;
100350   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100351   if (!arg6) {
100352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100353     return 0;
100354   }
100355   {
100356     try {
100357       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100358     } catch (std::out_of_range& e) {
100359       {
100360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100361       };
100362     } catch (std::exception& e) {
100363       {
100364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100365       };
100366     } catch (Dali::DaliException e) {
100367       {
100368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100369       };
100370     } catch (...) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100373       };
100374     }
100375   }
100376
100377   jresult = result;
100378   return jresult;
100379 }
100380
100381
100382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100383   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100384
100385   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100386   {
100387     try {
100388       (*arg1)->Reference();
100389     } catch (std::out_of_range& e) {
100390       {
100391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100392       };
100393     } catch (std::exception& e) {
100394       {
100395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100396       };
100397     } catch (Dali::DaliException e) {
100398       {
100399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100400       };
100401     } catch (...) {
100402       {
100403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100404       };
100405     }
100406   }
100407
100408 }
100409
100410
100411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100412   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100413
100414   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100415   {
100416     try {
100417       (*arg1)->Unreference();
100418     } catch (std::out_of_range& e) {
100419       {
100420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100421       };
100422     } catch (std::exception& e) {
100423       {
100424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100425       };
100426     } catch (Dali::DaliException e) {
100427       {
100428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100429       };
100430     } catch (...) {
100431       {
100432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100433       };
100434     }
100435   }
100436
100437 }
100438
100439
100440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100441   int jresult ;
100442   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100443   int result;
100444
100445   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100446   {
100447     try {
100448       result = (int)(*arg1)->ReferenceCount();
100449     } catch (std::out_of_range& e) {
100450       {
100451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100452       };
100453     } catch (std::exception& e) {
100454       {
100455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100456       };
100457     } catch (Dali::DaliException e) {
100458       {
100459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100460       };
100461     } catch (...) {
100462       {
100463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100464       };
100465     }
100466   }
100467
100468   jresult = result;
100469   return jresult;
100470 }
100471
100472
100473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100474   unsigned int jresult ;
100475   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100476   bool result;
100477
100478   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100479   {
100480     try {
100481       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100482     } catch (std::out_of_range& e) {
100483       {
100484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100485       };
100486     } catch (std::exception& e) {
100487       {
100488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (Dali::DaliException e) {
100491       {
100492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100493       };
100494     } catch (...) {
100495       {
100496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100497       };
100498     }
100499   }
100500
100501   jresult = result;
100502   return jresult;
100503 }
100504
100505
100506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100507   unsigned long jresult ;
100508   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100509   std::size_t result;
100510
100511   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100512   {
100513     try {
100514       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100515     } catch (std::out_of_range& e) {
100516       {
100517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100518       };
100519     } catch (std::exception& e) {
100520       {
100521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100522       };
100523     } catch (Dali::DaliException e) {
100524       {
100525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100526       };
100527     } catch (...) {
100528       {
100529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100530       };
100531     }
100532   }
100533
100534   jresult = (unsigned long)result;
100535   return jresult;
100536 }
100537
100538
100539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100540   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100541   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100542
100543   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100544   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100545   {
100546     try {
100547       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100548     } catch (std::out_of_range& e) {
100549       {
100550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100551       };
100552     } catch (std::exception& e) {
100553       {
100554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100555       };
100556     } catch (Dali::DaliException e) {
100557       {
100558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100559       };
100560     } catch (...) {
100561       {
100562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100563       };
100564     }
100565   }
100566
100567 }
100568
100569
100570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100571   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100572   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100573
100574   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100575   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100576   {
100577     try {
100578       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100579     } catch (std::out_of_range& e) {
100580       {
100581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100582       };
100583     } catch (std::exception& e) {
100584       {
100585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100586       };
100587     } catch (Dali::DaliException e) {
100588       {
100589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100590       };
100591     } catch (...) {
100592       {
100593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100594       };
100595     }
100596   }
100597
100598 }
100599
100600
100601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100602   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100603   Dali::Toolkit::Control arg2 ;
100604   Dali::Toolkit::Control *argp2 ;
100605
100606   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100607   argp2 = (Dali::Toolkit::Control *)jarg2;
100608   if (!argp2) {
100609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100610     return ;
100611   }
100612   arg2 = *argp2;
100613   {
100614     try {
100615       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100616     } catch (std::out_of_range& e) {
100617       {
100618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100619       };
100620     } catch (std::exception& e) {
100621       {
100622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100623       };
100624     } catch (Dali::DaliException e) {
100625       {
100626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100627       };
100628     } catch (...) {
100629       {
100630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100631       };
100632     }
100633   }
100634
100635 }
100636
100637
100638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100639   void * jresult ;
100640   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100641
100642   {
100643     try {
100644       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100645     } catch (std::out_of_range& e) {
100646       {
100647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100648       };
100649     } catch (std::exception& e) {
100650       {
100651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100652       };
100653     } catch (Dali::DaliException e) {
100654       {
100655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100656       };
100657     } catch (...) {
100658       {
100659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100660       };
100661     }
100662   }
100663
100664   jresult = (void *)result;
100665   return jresult;
100666 }
100667
100668
100669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100670   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100671
100672   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100673   {
100674     try {
100675       delete arg1;
100676     } catch (std::out_of_range& e) {
100677       {
100678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100679       };
100680     } catch (std::exception& e) {
100681       {
100682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100683       };
100684     } catch (Dali::DaliException e) {
100685       {
100686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100687       };
100688     } catch (...) {
100689       {
100690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100691       };
100692     }
100693   }
100694
100695 }
100696
100697 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100698   Dali::RefObject *result = NULL;
100699
100700   if (arg1)
100701   {
100702     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100703   }
100704   return result;
100705 }
100706
100707 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100708     return (Dali::RefObject *)jarg1;
100709 }
100710
100711 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100712     return (Dali::SignalObserver *)jarg1;
100713 }
100714
100715 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100716     return (Dali::ConnectionTrackerInterface *)jarg1;
100717 }
100718
100719 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100720     return (Dali::BaseHandle *)jarg1;
100721 }
100722
100723 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100724     return (Dali::BaseHandle *)jarg1;
100725 }
100726
100727 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100728     return (Dali::BaseHandle *)jarg1;
100729 }
100730
100731 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100732     return (Dali::BaseHandle *)jarg1;
100733 }
100734
100735 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100736     return (Dali::BaseHandle *)jarg1;
100737 }
100738
100739 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100740     return (Dali::BaseHandle *)jarg1;
100741 }
100742
100743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100744     return (Dali::BaseHandle *)jarg1;
100745 }
100746
100747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100748     return (Dali::BaseHandle *)jarg1;
100749 }
100750
100751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100752     return (Dali::BaseHandle *)jarg1;
100753 }
100754
100755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100756     return (Dali::BaseHandle *)jarg1;
100757 }
100758
100759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100760     return (Dali::BaseHandle *)jarg1;
100761 }
100762
100763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100764     return (Dali::BaseHandle *)jarg1;
100765 }
100766
100767 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100768     return (Dali::BaseHandle *)jarg1;
100769 }
100770
100771 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100772     return (Dali::Handle *)jarg1;
100773 }
100774
100775 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100776     return (Dali::Handle *)jarg1;
100777 }
100778
100779 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100780     return (Dali::BaseHandle *)jarg1;
100781 }
100782
100783 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100784     return (Dali::BaseHandle *)jarg1;
100785 }
100786
100787 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100788     return (Dali::Handle *)jarg1;
100789 }
100790
100791 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100792     return (Dali::BaseHandle *)jarg1;
100793 }
100794
100795 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100796     return (Dali::Handle *)jarg1;
100797 }
100798
100799 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100800     return (Dali::GestureDetector *)jarg1;
100801 }
100802
100803 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100804     return (Dali::Gesture *)jarg1;
100805 }
100806
100807 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100808     return (Dali::Handle *)jarg1;
100809 }
100810
100811 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100812     return (Dali::Actor *)jarg1;
100813 }
100814
100815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100816     return (Dali::BaseHandle *)jarg1;
100817 }
100818
100819 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100820     return (Dali::RefObject *)jarg1;
100821 }
100822
100823 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100824     return (Dali::Actor *)jarg1;
100825 }
100826
100827 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100828     return (Dali::GestureDetector *)jarg1;
100829 }
100830
100831 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100832     return (Dali::Gesture *)jarg1;
100833 }
100834
100835 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100836     return (Dali::GestureDetector *)jarg1;
100837 }
100838
100839 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100840     return (Dali::Gesture *)jarg1;
100841 }
100842
100843 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100844     return (Dali::GestureDetector *)jarg1;
100845 }
100846
100847 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100848     return (Dali::Gesture *)jarg1;
100849 }
100850
100851 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100852     return (Dali::BaseHandle *)jarg1;
100853 }
100854
100855 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100856     return (Dali::Handle *)jarg1;
100857 }
100858
100859 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100860     return (Dali::Handle *)jarg1;
100861 }
100862
100863 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100864     return (Dali::Handle *)jarg1;
100865 }
100866
100867 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100868     return (Dali::Image *)jarg1;
100869 }
100870
100871 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100872     return (Dali::Image *)jarg1;
100873 }
100874
100875 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100876     return (Dali::Image *)jarg1;
100877 }
100878
100879 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100880     return (Dali::RefObject *)jarg1;
100881 }
100882
100883 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100884     return (Dali::Image *)jarg1;
100885 }
100886
100887 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100888     return (Dali::Image *)jarg1;
100889 }
100890
100891 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100892     return (Dali::ResourceImage *)jarg1;
100893 }
100894
100895 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100896     return (Dali::Actor *)jarg1;
100897 }
100898
100899 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100900     return (Dali::BaseHandle *)jarg1;
100901 }
100902
100903 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100904     return (Dali::BaseHandle *)jarg1;
100905 }
100906
100907
100908 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100909     return (Dali::BaseHandle *)jarg1;
100910 }
100911
100912 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100913     return (Dali::BaseHandle *)jarg1;
100914 }
100915
100916 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100917     return (Dali::CustomActorImpl *)jarg1;
100918 }
100919
100920 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100921     return (Dali::CustomActor *)jarg1;
100922 }
100923
100924 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100925     return (Dali::BaseHandle *)jarg1;
100926 }
100927
100928 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100929     return (Dali::Toolkit::Control *)jarg1;
100930 }
100931
100932 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100933     return (Dali::Toolkit::Control *)jarg1;
100934 }
100935
100936 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100937     return (Dali::Toolkit::Button *)jarg1;
100938 }
100939
100940 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100941     return (Dali::Toolkit::Button *)jarg1;
100942 }
100943
100944 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100945     return (Dali::Toolkit::Button *)jarg1;
100946 }
100947
100948 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100949     return (Dali::Toolkit::Control *)jarg1;
100950 }
100951
100952 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100953     return (Dali::Toolkit::Control *)jarg1;
100954 }
100955
100956 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100957     return (Dali::Toolkit::Control *)jarg1;
100958 }
100959
100960 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100961     return (Dali::Toolkit::Control *)jarg1;
100962 }
100963
100964 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100965     return (Dali::Toolkit::Control *)jarg1;
100966 }
100967
100968 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100969     return (Dali::RefObject *)jarg1;
100970 }
100971
100972 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100973     return (Dali::Toolkit::Scrollable *)jarg1;
100974 }
100975
100976 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100977     return (Dali::BaseHandle *)jarg1;
100978 }
100979
100980 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100981     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100982 }
100983
100984 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100985     return (Dali::RefObject *)jarg1;
100986 }
100987
100988 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100989     return (Dali::Toolkit::Ruler *)jarg1;
100990 }
100991
100992 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100993     return (Dali::Toolkit::Ruler *)jarg1;
100994 }
100995
100996 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100997     return (Dali::Toolkit::Scrollable *)jarg1;
100998 }
100999
101000 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101001     return (Dali::Toolkit::Control *)jarg1;
101002 }
101003
101004
101005 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101006     return (Dali::Toolkit::Control *)jarg1;
101007 }
101008
101009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101010     return (Dali::BaseHandle *)jarg1;
101011 }
101012
101013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101014     return (Dali::BaseHandle *)jarg1;
101015 }
101016
101017 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101018     return (Dali::Toolkit::Control *)jarg1;
101019 }
101020
101021 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101022     return (Dali::Toolkit::Control *)jarg1;
101023 }
101024
101025 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101026     return (Dali::Toolkit::Control *)jarg1;
101027 }
101028
101029 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101030     return (Dali::Toolkit::Control *)jarg1;
101031 }
101032
101033 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101034     return (Dali::Toolkit::Control *)jarg1;
101035 }
101036
101037 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101038     return (Dali::Toolkit::Control *)jarg1;
101039 }
101040
101041 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101042     return (Dali::Toolkit::PageTurnView *)jarg1;
101043 }
101044
101045 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101046     return (Dali::Toolkit::PageTurnView *)jarg1;
101047 }
101048
101049 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101050     return (Dali::Toolkit::Button *)jarg1;
101051 }
101052
101053 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101054     return (Dali::BaseHandle *)jarg1;
101055 }
101056
101057 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101058     return (Dali::BaseHandle *)jarg1;
101059 }
101060
101061 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101062     return (Dali::BaseHandle *)jarg1;
101063 }
101064
101065
101066 //for PixelBuffer and ImageLoading
101067
101068 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101069     return (Dali::BaseHandle *)jarg1;
101070 }
101071
101072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101073   void * jresult ;
101074   unsigned int arg1 ;
101075   unsigned int arg2 ;
101076   Dali::Pixel::Format arg3 ;
101077   Dali::Devel::PixelBuffer result;
101078
101079   arg1 = (unsigned int)jarg1;
101080   arg2 = (unsigned int)jarg2;
101081   arg3 = (Dali::Pixel::Format)jarg3;
101082   {
101083     try {
101084       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101085     } catch (std::out_of_range& e) {
101086       {
101087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101088       };
101089     } catch (std::exception& e) {
101090       {
101091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101092       };
101093     } catch (...) {
101094       {
101095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101096       };
101097     }
101098   }
101099   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101100   return jresult;
101101 }
101102
101103
101104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101105   void * jresult ;
101106   Dali::Devel::PixelBuffer *result = 0 ;
101107
101108   {
101109     try {
101110       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101111     } catch (std::out_of_range& e) {
101112       {
101113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101114       };
101115     } catch (std::exception& e) {
101116       {
101117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101118       };
101119     } catch (...) {
101120       {
101121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101122       };
101123     }
101124   }
101125   jresult = (void *)result;
101126   return jresult;
101127 }
101128
101129
101130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101131   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101132
101133   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101134   {
101135     try {
101136       delete arg1;
101137     } catch (std::out_of_range& e) {
101138       {
101139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101140       };
101141     } catch (std::exception& e) {
101142       {
101143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101144       };
101145     } catch (...) {
101146       {
101147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101148       };
101149     }
101150   }
101151 }
101152
101153
101154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101155   void * jresult ;
101156   Dali::Devel::PixelBuffer *arg1 = 0 ;
101157   Dali::Devel::PixelBuffer *result = 0 ;
101158
101159   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101160   if (!arg1) {
101161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101162     return 0;
101163   }
101164   {
101165     try {
101166       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101167     } catch (std::out_of_range& e) {
101168       {
101169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101170       };
101171     } catch (std::exception& e) {
101172       {
101173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101174       };
101175     } catch (...) {
101176       {
101177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101178       };
101179     }
101180   }
101181   jresult = (void *)result;
101182   return jresult;
101183 }
101184
101185
101186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101187   void * jresult ;
101188   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101189   Dali::Devel::PixelBuffer *arg2 = 0 ;
101190   Dali::Devel::PixelBuffer *result = 0 ;
101191
101192   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101193   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101194   if (!arg2) {
101195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101196     return 0;
101197   }
101198   {
101199     try {
101200       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101201     } catch (std::out_of_range& e) {
101202       {
101203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101204       };
101205     } catch (std::exception& e) {
101206       {
101207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101208       };
101209     } catch (...) {
101210       {
101211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101212       };
101213     }
101214   }
101215   jresult = (void *)result;
101216   return jresult;
101217 }
101218
101219
101220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101221   void * jresult ;
101222   Dali::Devel::PixelBuffer *arg1 = 0 ;
101223   Dali::PixelData result;
101224
101225   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101226   if (!arg1) {
101227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101228     return 0;
101229   }
101230   {
101231     try {
101232       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101233     } catch (std::out_of_range& e) {
101234       {
101235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101236       };
101237     } catch (std::exception& e) {
101238       {
101239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101240       };
101241     } catch (...) {
101242       {
101243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101244       };
101245     }
101246   }
101247   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101248   return jresult;
101249 }
101250
101251
101252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101253   void * jresult ;
101254   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101255   Dali::PixelData result;
101256
101257   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101258   {
101259     try {
101260       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101261     } catch (std::out_of_range& e) {
101262       {
101263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101264       };
101265     } catch (std::exception& e) {
101266       {
101267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101268       };
101269     } catch (...) {
101270       {
101271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101272       };
101273     }
101274   }
101275   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101276   return jresult;
101277 }
101278
101279
101280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101281   void * jresult ;
101282   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101283   unsigned char *result = 0 ;
101284
101285   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101286   {
101287     try {
101288       result = (unsigned char *)(arg1)->GetBuffer();
101289     } catch (std::out_of_range& e) {
101290       {
101291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101292       };
101293     } catch (std::exception& e) {
101294       {
101295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101296       };
101297     } catch (...) {
101298       {
101299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101300       };
101301     }
101302   }
101303   jresult = (void *)result;
101304   return jresult;
101305 }
101306
101307
101308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101309   unsigned int jresult ;
101310   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101311   unsigned int result;
101312
101313   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101314   {
101315     try {
101316       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101317     } catch (std::out_of_range& e) {
101318       {
101319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101320       };
101321     } catch (std::exception& e) {
101322       {
101323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101324       };
101325     } catch (...) {
101326       {
101327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101328       };
101329     }
101330   }
101331   jresult = result;
101332   return jresult;
101333 }
101334
101335
101336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101337   unsigned int jresult ;
101338   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101339   unsigned int result;
101340
101341   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101342   {
101343     try {
101344       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101345     } catch (std::out_of_range& e) {
101346       {
101347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101348       };
101349     } catch (std::exception& e) {
101350       {
101351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101352       };
101353     } catch (...) {
101354       {
101355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101356       };
101357     }
101358   }
101359   jresult = result;
101360   return jresult;
101361 }
101362
101363
101364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101365   int jresult ;
101366   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101367   Dali::Pixel::Format result;
101368
101369   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101370   {
101371     try {
101372       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101373     } catch (std::out_of_range& e) {
101374       {
101375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101376       };
101377     } catch (std::exception& e) {
101378       {
101379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101380       };
101381     } catch (...) {
101382       {
101383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101384       };
101385     }
101386   }
101387   jresult = (int)result;
101388   return jresult;
101389 }
101390
101391
101392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101393   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101394   Dali::Devel::PixelBuffer arg2 ;
101395   float arg3 ;
101396   bool arg4 ;
101397   Dali::Devel::PixelBuffer *argp2 ;
101398
101399   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101400   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101401   if (!argp2) {
101402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101403     return ;
101404   }
101405   arg2 = *argp2;
101406   arg3 = (float)jarg3;
101407   arg4 = jarg4 ? true : false;
101408   {
101409     try {
101410       (arg1)->ApplyMask(arg2,arg3,arg4);
101411     } catch (std::out_of_range& e) {
101412       {
101413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101414       };
101415     } catch (std::exception& e) {
101416       {
101417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101418       };
101419     } catch (...) {
101420       {
101421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101422       };
101423     }
101424   }
101425 }
101426
101427
101428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101429   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101430   Dali::Devel::PixelBuffer arg2 ;
101431   float arg3 ;
101432   Dali::Devel::PixelBuffer *argp2 ;
101433
101434   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101435   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101436   if (!argp2) {
101437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101438     return ;
101439   }
101440   arg2 = *argp2;
101441   arg3 = (float)jarg3;
101442   {
101443     try {
101444       (arg1)->ApplyMask(arg2,arg3);
101445     } catch (std::out_of_range& e) {
101446       {
101447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101448       };
101449     } catch (std::exception& e) {
101450       {
101451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101452       };
101453     } catch (...) {
101454       {
101455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101456       };
101457     }
101458   }
101459 }
101460
101461
101462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101463   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101464   Dali::Devel::PixelBuffer arg2 ;
101465   Dali::Devel::PixelBuffer *argp2 ;
101466
101467   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101468   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101469   if (!argp2) {
101470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101471     return ;
101472   }
101473   arg2 = *argp2;
101474   {
101475     try {
101476       (arg1)->ApplyMask(arg2);
101477     } catch (std::out_of_range& e) {
101478       {
101479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101480       };
101481     } catch (std::exception& e) {
101482       {
101483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101484       };
101485     } catch (...) {
101486       {
101487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101488       };
101489     }
101490   }
101491 }
101492
101493
101494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101495   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101496   float arg2 ;
101497
101498   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101499   arg2 = (float)jarg2;
101500   {
101501     try {
101502       (arg1)->ApplyGaussianBlur(arg2);
101503     } catch (std::out_of_range& e) {
101504       {
101505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101506       };
101507     } catch (std::exception& e) {
101508       {
101509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101510       };
101511     } catch (...) {
101512       {
101513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101514       };
101515     }
101516   }
101517 }
101518
101519
101520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101521   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101522   uint16_t arg2 ;
101523   uint16_t arg3 ;
101524   uint16_t arg4 ;
101525   uint16_t arg5 ;
101526
101527   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101528   arg2 = (uint16_t)jarg2;
101529   arg3 = (uint16_t)jarg3;
101530   arg4 = (uint16_t)jarg4;
101531   arg5 = (uint16_t)jarg5;
101532   {
101533     try {
101534       (arg1)->Crop(arg2,arg3,arg4,arg5);
101535     } catch (std::out_of_range& e) {
101536       {
101537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101538       };
101539     } catch (std::exception& e) {
101540       {
101541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101542       };
101543     } catch (...) {
101544       {
101545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101546       };
101547     }
101548   }
101549 }
101550
101551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_GetMetadata(void * jarg1, void * jarg2) {
101552   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101553   Dali::Property::Map *arg2 = (Dali::Property::Map *) 0 ;
101554
101555   arg1 = (Dali::Devel::PixelBuffer*)jarg1;
101556   arg2 = (Dali::Property::Map*)jarg2;
101557   {
101558     try {
101559       (arg1)->GetMetadata(*arg2);
101560     } catch (std::out_of_range& e) {
101561       {
101562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101563       };
101564     } catch (std::exception& e) {
101565       {
101566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101567       };
101568     } catch (...) {
101569       {
101570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101571       };
101572     }
101573   }
101574 }
101575
101576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101577   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101578   uint16_t arg2 ;
101579   uint16_t arg3 ;
101580
101581   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101582   arg2 = (uint16_t)jarg2;
101583   arg3 = (uint16_t)jarg3;
101584   {
101585     try {
101586       (arg1)->Resize(arg2,arg3);
101587     } catch (std::out_of_range& e) {
101588       {
101589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101590       };
101591     } catch (std::exception& e) {
101592       {
101593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101594       };
101595     } catch (...) {
101596       {
101597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101598       };
101599     }
101600   }
101601 }
101602
101603
101604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
101605   void * jresult ;
101606   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
101607   Dali::Devel::PixelBuffer *result = 0 ;
101608
101609   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
101610   {
101611     try {
101612       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
101613     } catch (std::out_of_range& e) {
101614       {
101615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101616       };
101617     } catch (std::exception& e) {
101618       {
101619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101620       };
101621     } catch (...) {
101622       {
101623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101624       };
101625     }
101626   }
101627   jresult = (void *)result;
101628   return jresult;
101629 }
101630
101631
101632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101633   void * jresult ;
101634   std::string *arg1 = 0 ;
101635   Dali::ImageDimensions arg2 ;
101636   Dali::FittingMode::Type arg3 ;
101637   Dali::SamplingMode::Type arg4 ;
101638   bool arg5 ;
101639   Dali::ImageDimensions *argp2 ;
101640   Dali::Devel::PixelBuffer result;
101641
101642   if (!jarg1) {
101643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101644     return 0;
101645   }
101646   std::string arg1_str(jarg1);
101647   arg1 = &arg1_str;
101648   argp2 = (Dali::ImageDimensions *)jarg2;
101649   if (!argp2) {
101650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101651     return 0;
101652   }
101653   arg2 = *argp2;
101654   arg3 = (Dali::FittingMode::Type)jarg3;
101655   arg4 = (Dali::SamplingMode::Type)jarg4;
101656   arg5 = jarg5 ? true : false;
101657   {
101658     try {
101659       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101660     } catch (std::out_of_range& e) {
101661       {
101662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101663       };
101664     } catch (std::exception& e) {
101665       {
101666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101667       };
101668     } catch (...) {
101669       {
101670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101671       };
101672     }
101673   }
101674   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101675
101676   return jresult;
101677 }
101678
101679
101680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101681   void * jresult ;
101682   std::string *arg1 = 0 ;
101683   Dali::ImageDimensions arg2 ;
101684   Dali::FittingMode::Type arg3 ;
101685   Dali::SamplingMode::Type arg4 ;
101686   Dali::ImageDimensions *argp2 ;
101687   Dali::Devel::PixelBuffer result;
101688
101689   if (!jarg1) {
101690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101691     return 0;
101692   }
101693   std::string arg1_str(jarg1);
101694   arg1 = &arg1_str;
101695   argp2 = (Dali::ImageDimensions *)jarg2;
101696   if (!argp2) {
101697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101698     return 0;
101699   }
101700   arg2 = *argp2;
101701   arg3 = (Dali::FittingMode::Type)jarg3;
101702   arg4 = (Dali::SamplingMode::Type)jarg4;
101703   {
101704     try {
101705       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101706     } catch (std::out_of_range& e) {
101707       {
101708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101709       };
101710     } catch (std::exception& e) {
101711       {
101712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101713       };
101714     } catch (...) {
101715       {
101716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101717       };
101718     }
101719   }
101720   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101721
101722   return jresult;
101723 }
101724
101725
101726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101727   void * jresult ;
101728   std::string *arg1 = 0 ;
101729   Dali::ImageDimensions arg2 ;
101730   Dali::FittingMode::Type arg3 ;
101731   Dali::ImageDimensions *argp2 ;
101732   Dali::Devel::PixelBuffer result;
101733
101734   if (!jarg1) {
101735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101736     return 0;
101737   }
101738   std::string arg1_str(jarg1);
101739   arg1 = &arg1_str;
101740   argp2 = (Dali::ImageDimensions *)jarg2;
101741   if (!argp2) {
101742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101743     return 0;
101744   }
101745   arg2 = *argp2;
101746   arg3 = (Dali::FittingMode::Type)jarg3;
101747   {
101748     try {
101749       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101750     } catch (std::out_of_range& e) {
101751       {
101752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101753       };
101754     } catch (std::exception& e) {
101755       {
101756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101757       };
101758     } catch (...) {
101759       {
101760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101761       };
101762     }
101763   }
101764   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101765
101766   return jresult;
101767 }
101768
101769
101770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101771   void * jresult ;
101772   std::string *arg1 = 0 ;
101773   Dali::ImageDimensions arg2 ;
101774   Dali::ImageDimensions *argp2 ;
101775   Dali::Devel::PixelBuffer result;
101776
101777   if (!jarg1) {
101778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101779     return 0;
101780   }
101781   std::string arg1_str(jarg1);
101782   arg1 = &arg1_str;
101783   argp2 = (Dali::ImageDimensions *)jarg2;
101784   if (!argp2) {
101785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101786     return 0;
101787   }
101788   arg2 = *argp2;
101789   {
101790     try {
101791       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101792     } catch (std::out_of_range& e) {
101793       {
101794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101795       };
101796     } catch (std::exception& e) {
101797       {
101798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101799       };
101800     } catch (...) {
101801       {
101802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101803       };
101804     }
101805   }
101806   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101807
101808   return jresult;
101809 }
101810
101811
101812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101813   void * jresult ;
101814   std::string *arg1 = 0 ;
101815   Dali::Devel::PixelBuffer result;
101816
101817   if (!jarg1) {
101818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101819     return 0;
101820   }
101821   std::string arg1_str(jarg1);
101822   arg1 = &arg1_str;
101823   {
101824     try {
101825       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101826     } catch (std::out_of_range& e) {
101827       {
101828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101829       };
101830     } catch (std::exception& e) {
101831       {
101832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101833       };
101834     } catch (...) {
101835       {
101836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101837       };
101838     }
101839   }
101840   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101841
101842   return jresult;
101843 }
101844
101845
101846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101847   void * jresult ;
101848   std::string *arg1 = 0 ;
101849   Dali::ImageDimensions arg2 ;
101850   Dali::FittingMode::Type arg3 ;
101851   Dali::SamplingMode::Type arg4 ;
101852   bool arg5 ;
101853   Dali::ImageDimensions *argp2 ;
101854   Dali::ImageDimensions result;
101855
101856   if (!jarg1) {
101857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101858     return 0;
101859   }
101860   std::string arg1_str(jarg1);
101861   arg1 = &arg1_str;
101862   argp2 = (Dali::ImageDimensions *)jarg2;
101863   if (!argp2) {
101864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101865     return 0;
101866   }
101867   arg2 = *argp2;
101868   arg3 = (Dali::FittingMode::Type)jarg3;
101869   arg4 = (Dali::SamplingMode::Type)jarg4;
101870   arg5 = jarg5 ? true : false;
101871   {
101872     try {
101873       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101874     } catch (std::out_of_range& e) {
101875       {
101876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101877       };
101878     } catch (std::exception& e) {
101879       {
101880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101881       };
101882     } catch (...) {
101883       {
101884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101885       };
101886     }
101887   }
101888   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101889
101890   return jresult;
101891 }
101892
101893
101894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101895   void * jresult ;
101896   std::string *arg1 = 0 ;
101897   Dali::ImageDimensions arg2 ;
101898   Dali::FittingMode::Type arg3 ;
101899   Dali::SamplingMode::Type arg4 ;
101900   Dali::ImageDimensions *argp2 ;
101901   Dali::ImageDimensions result;
101902
101903   if (!jarg1) {
101904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101905     return 0;
101906   }
101907   std::string arg1_str(jarg1);
101908   arg1 = &arg1_str;
101909   argp2 = (Dali::ImageDimensions *)jarg2;
101910   if (!argp2) {
101911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101912     return 0;
101913   }
101914   arg2 = *argp2;
101915   arg3 = (Dali::FittingMode::Type)jarg3;
101916   arg4 = (Dali::SamplingMode::Type)jarg4;
101917   {
101918     try {
101919       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101920     } catch (std::out_of_range& e) {
101921       {
101922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101923       };
101924     } catch (std::exception& e) {
101925       {
101926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101927       };
101928     } catch (...) {
101929       {
101930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101931       };
101932     }
101933   }
101934   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101935
101936   return jresult;
101937 }
101938
101939
101940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101941   void * jresult ;
101942   std::string *arg1 = 0 ;
101943   Dali::ImageDimensions arg2 ;
101944   Dali::FittingMode::Type arg3 ;
101945   Dali::ImageDimensions *argp2 ;
101946   Dali::ImageDimensions result;
101947
101948   if (!jarg1) {
101949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101950     return 0;
101951   }
101952   std::string arg1_str(jarg1);
101953   arg1 = &arg1_str;
101954   argp2 = (Dali::ImageDimensions *)jarg2;
101955   if (!argp2) {
101956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101957     return 0;
101958   }
101959   arg2 = *argp2;
101960   arg3 = (Dali::FittingMode::Type)jarg3;
101961   {
101962     try {
101963       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101964     } catch (std::out_of_range& e) {
101965       {
101966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101967       };
101968     } catch (std::exception& e) {
101969       {
101970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101971       };
101972     } catch (...) {
101973       {
101974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101975       };
101976     }
101977   }
101978   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101979
101980   return jresult;
101981 }
101982
101983
101984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101985   void * jresult ;
101986   std::string *arg1 = 0 ;
101987   Dali::ImageDimensions arg2 ;
101988   Dali::ImageDimensions *argp2 ;
101989   Dali::ImageDimensions result;
101990
101991   if (!jarg1) {
101992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101993     return 0;
101994   }
101995   std::string arg1_str(jarg1);
101996   arg1 = &arg1_str;
101997   argp2 = (Dali::ImageDimensions *)jarg2;
101998   if (!argp2) {
101999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102000     return 0;
102001   }
102002   arg2 = *argp2;
102003   {
102004     try {
102005       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102006     } catch (std::out_of_range& e) {
102007       {
102008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102009       };
102010     } catch (std::exception& e) {
102011       {
102012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (...) {
102015       {
102016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102017       };
102018     }
102019   }
102020   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102021
102022   return jresult;
102023 }
102024
102025
102026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102027   void * jresult ;
102028   std::string *arg1 = 0 ;
102029   Dali::ImageDimensions result;
102030
102031   if (!jarg1) {
102032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102033     return 0;
102034   }
102035   std::string arg1_str(jarg1);
102036   arg1 = &arg1_str;
102037   {
102038     try {
102039       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102040     } catch (std::out_of_range& e) {
102041       {
102042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102043       };
102044     } catch (std::exception& e) {
102045       {
102046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102047       };
102048     } catch (...) {
102049       {
102050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102051       };
102052     }
102053   }
102054   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102055
102056   return jresult;
102057 }
102058
102059
102060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102061   void * jresult ;
102062   std::string *arg1 = 0 ;
102063   Dali::ImageDimensions arg2 ;
102064   Dali::FittingMode::Type arg3 ;
102065   Dali::SamplingMode::Type arg4 ;
102066   bool arg5 ;
102067   Dali::ImageDimensions *argp2 ;
102068   Dali::Devel::PixelBuffer result;
102069
102070   if (!jarg1) {
102071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102072     return 0;
102073   }
102074   std::string arg1_str(jarg1);
102075   arg1 = &arg1_str;
102076   argp2 = (Dali::ImageDimensions *)jarg2;
102077   if (!argp2) {
102078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102079     return 0;
102080   }
102081   arg2 = *argp2;
102082   arg3 = (Dali::FittingMode::Type)jarg3;
102083   arg4 = (Dali::SamplingMode::Type)jarg4;
102084   arg5 = jarg5 ? true : false;
102085   {
102086     try {
102087       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102088     } catch (std::out_of_range& e) {
102089       {
102090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102091       };
102092     } catch (std::exception& e) {
102093       {
102094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102095       };
102096     } catch (...) {
102097       {
102098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102099       };
102100     }
102101   }
102102   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102103
102104   return jresult;
102105 }
102106
102107
102108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102109   void * jresult ;
102110   std::string *arg1 = 0 ;
102111   Dali::ImageDimensions arg2 ;
102112   Dali::FittingMode::Type arg3 ;
102113   Dali::SamplingMode::Type arg4 ;
102114   Dali::ImageDimensions *argp2 ;
102115   Dali::Devel::PixelBuffer result;
102116
102117   if (!jarg1) {
102118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102119     return 0;
102120   }
102121   std::string arg1_str(jarg1);
102122   arg1 = &arg1_str;
102123   argp2 = (Dali::ImageDimensions *)jarg2;
102124   if (!argp2) {
102125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102126     return 0;
102127   }
102128   arg2 = *argp2;
102129   arg3 = (Dali::FittingMode::Type)jarg3;
102130   arg4 = (Dali::SamplingMode::Type)jarg4;
102131   {
102132     try {
102133       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102134     } catch (std::out_of_range& e) {
102135       {
102136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102137       };
102138     } catch (std::exception& e) {
102139       {
102140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102141       };
102142     } catch (...) {
102143       {
102144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102145       };
102146     }
102147   }
102148   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102149
102150   return jresult;
102151 }
102152
102153
102154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102155   void * jresult ;
102156   std::string *arg1 = 0 ;
102157   Dali::ImageDimensions arg2 ;
102158   Dali::FittingMode::Type arg3 ;
102159   Dali::ImageDimensions *argp2 ;
102160   Dali::Devel::PixelBuffer result;
102161
102162   if (!jarg1) {
102163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102164     return 0;
102165   }
102166   std::string arg1_str(jarg1);
102167   arg1 = &arg1_str;
102168   argp2 = (Dali::ImageDimensions *)jarg2;
102169   if (!argp2) {
102170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102171     return 0;
102172   }
102173   arg2 = *argp2;
102174   arg3 = (Dali::FittingMode::Type)jarg3;
102175   {
102176     try {
102177       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102178     } catch (std::out_of_range& e) {
102179       {
102180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102181       };
102182     } catch (std::exception& e) {
102183       {
102184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102185       };
102186     } catch (...) {
102187       {
102188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102189       };
102190     }
102191   }
102192   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102193
102194   return jresult;
102195 }
102196
102197
102198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102199   void * jresult ;
102200   std::string *arg1 = 0 ;
102201   Dali::ImageDimensions arg2 ;
102202   Dali::ImageDimensions *argp2 ;
102203   Dali::Devel::PixelBuffer result;
102204
102205   if (!jarg1) {
102206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102207     return 0;
102208   }
102209   std::string arg1_str(jarg1);
102210   arg1 = &arg1_str;
102211   argp2 = (Dali::ImageDimensions *)jarg2;
102212   if (!argp2) {
102213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102214     return 0;
102215   }
102216   arg2 = *argp2;
102217   {
102218     try {
102219       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102220     } catch (std::out_of_range& e) {
102221       {
102222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102223       };
102224     } catch (std::exception& e) {
102225       {
102226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102227       };
102228     } catch (...) {
102229       {
102230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102231       };
102232     }
102233   }
102234   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102235
102236   return jresult;
102237 }
102238
102239
102240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102241   void * jresult ;
102242   std::string *arg1 = 0 ;
102243   Dali::Devel::PixelBuffer result;
102244
102245   if (!jarg1) {
102246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102247     return 0;
102248   }
102249   std::string arg1_str(jarg1);
102250   arg1 = &arg1_str;
102251   {
102252     try {
102253       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102254     } catch (std::out_of_range& e) {
102255       {
102256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102257       };
102258     } catch (std::exception& e) {
102259       {
102260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102261       };
102262     } catch (...) {
102263       {
102264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102265       };
102266     }
102267   }
102268   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102269
102270   return jresult;
102271 }
102272
102273
102274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
102275   unsigned int arg1 ;
102276
102277   arg1 = (unsigned int)jarg1;
102278   {
102279     try {
102280       Dali::SetMaxTextureSize(arg1);
102281     } catch (std::out_of_range& e) {
102282       {
102283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102284       };
102285     } catch (std::exception& e) {
102286       {
102287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102288       };
102289     } catch (...) {
102290       {
102291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102292       };
102293     }
102294   }
102295 }
102296
102297
102298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
102299   unsigned int jresult ;
102300   unsigned int result;
102301
102302   {
102303     try {
102304       result = (unsigned int)Dali::GetMaxTextureSize();
102305     } catch (std::out_of_range& e) {
102306       {
102307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102308       };
102309     } catch (std::exception& e) {
102310       {
102311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102312       };
102313     } catch (...) {
102314       {
102315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102316       };
102317     }
102318   }
102319   jresult = result;
102320   return jresult;
102321 }
102322
102323
102324 #ifdef __cplusplus
102325 }
102326 #endif
102327