dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17
  18 #ifdef __cplusplus
  19 /* SwigValueWrapper is described in swig.swg */
  20 template<typename T> class SwigValueWrapper {
  21   struct SwigMovePointer {
  22     T *ptr;
  23     SwigMovePointer(T *p) : ptr(p) { }
  24     ~SwigMovePointer() { delete ptr; }
  25     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  26   } pointer;
  27   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  28   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  29 public:
  30   SwigValueWrapper() : pointer(0) { }
  31   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  32   operator T&() const { return *pointer.ptr; }
  33   T *operator&() { return pointer.ptr; }
  34 };
  35
  36 template <typename T> T SwigValueInit() {
  37   return T();
  38 }
  39 #endif
  40
  41 /* -----------------------------------------------------------------------------
  42  *  This section contains generic SWIG labels for method/variable
  43  *  declarations/attributes, and other compiler dependent labels.
  44  * ----------------------------------------------------------------------------- */
  45
  46 /* template workaround for compilers that cannot correctly implement the C++ standard */
  47 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  48 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  49 #  define SWIGTEMPLATEDISAMBIGUATOR template
  50 # elif defined(__HP_aCC)
  51 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  52 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  53 #  define SWIGTEMPLATEDISAMBIGUATOR template
  54 # else
  55 #  define SWIGTEMPLATEDISAMBIGUATOR
  56 # endif
  57 #endif
  58
  59 /* inline attribute */
  60 #ifndef SWIGINLINE
  61 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  62 #   define SWIGINLINE inline
  63 # else
  64 #   define SWIGINLINE
  65 # endif
  66 #endif
  67
  68 /* attribute recognised by some compilers to avoid 'unused' warnings */
  69 #ifndef SWIGUNUSED
  70 # if defined(__GNUC__)
  71 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  72 #     define SWIGUNUSED __attribute__ ((__unused__))
  73 #   else
  74 #     define SWIGUNUSED
  75 #   endif
  76 # elif defined(__ICC)
  77 #   define SWIGUNUSED __attribute__ ((__unused__))
  78 # else
  79 #   define SWIGUNUSED
  80 # endif
  81 #endif
  82
  83 #ifndef SWIG_MSC_UNSUPPRESS_4505
  84 # if defined(_MSC_VER)
  85 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  86 # endif
  87 #endif
  88
  89 #ifndef SWIGUNUSEDPARM
  90 # ifdef __cplusplus
  91 #   define SWIGUNUSEDPARM(p)
  92 # else
  93 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  94 # endif
  95 #endif
  96
  97 /* internal SWIG method */
  98 #ifndef SWIGINTERN
  99 # define SWIGINTERN static SWIGUNUSED
 100 #endif
 101
 102 /* internal inline SWIG method */
 103 #ifndef SWIGINTERNINLINE
 104 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 105 #endif
 106
 107 /* exporting methods */
 108 #if defined(__GNUC__)
 109 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 110 #    ifndef GCC_HASCLASSVISIBILITY
 111 #      define GCC_HASCLASSVISIBILITY
 112 #    endif
 113 #  endif
 114 #endif
 115
 116 #ifndef SWIGEXPORT
 117 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 118 #   if defined(STATIC_LINKED)
 119 #     define SWIGEXPORT
 120 #   else
 121 #     define SWIGEXPORT __declspec(dllexport)
 122 #   endif
 123 # else
 124 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 125 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 126 #   else
 127 #     define SWIGEXPORT
 128 #   endif
 129 # endif
 130 #endif
 131
 132 /* calling conventions for Windows */
 133 #ifndef SWIGSTDCALL
 134 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 135 #   define SWIGSTDCALL __stdcall
 136 # else
 137 #   define SWIGSTDCALL
 138 # endif
 139 #endif
 140
 141 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 142 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 143 # define _CRT_SECURE_NO_DEPRECATE
 144 #endif
 145
 146 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 147 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 148 # define _SCL_SECURE_NO_DEPRECATE
 149 #endif
 150
 151 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 152 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 153 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 154 #endif
 155
 156 /* Intel's compiler complains if a variable which was never initialised is
 157  * cast to void, which is a common idiom which we use to indicate that we
 158  * are aware a variable isn't used.  So we just silence that warning.
 159  * See: https://github.com/swig/swig/issues/192 for more discussion.
 160  */
 161 #ifdef __INTEL_COMPILER
 162 # pragma warning disable 592
 163 #endif
 164
 165
 166 #include <stdlib.h>
 167 #include <string.h>
 168 #include <stdio.h>
 169
 170
 171 /* Support for throwing C# exceptions from C/C++. There are two types:
 172  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 173 typedef enum {
 174   SWIG_CSharpApplicationException,
 175   SWIG_CSharpArithmeticException,
 176   SWIG_CSharpDivideByZeroException,
 177   SWIG_CSharpIndexOutOfRangeException,
 178   SWIG_CSharpInvalidCastException,
 179   SWIG_CSharpInvalidOperationException,
 180   SWIG_CSharpIOException,
 181   SWIG_CSharpNullReferenceException,
 182   SWIG_CSharpOutOfMemoryException,
 183   SWIG_CSharpOverflowException,
 184   SWIG_CSharpSystemException
 185 } SWIG_CSharpExceptionCodes;
 186
 187 typedef enum {
 188   SWIG_CSharpArgumentException,
 189   SWIG_CSharpArgumentNullException,
 190   SWIG_CSharpArgumentOutOfRangeException
 191 } SWIG_CSharpExceptionArgumentCodes;
 192
 193 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 195
 196 typedef struct {
 197   SWIG_CSharpExceptionCodes code;
 198   SWIG_CSharpExceptionCallback_t callback;
 199 } SWIG_CSharpException_t;
 200
 201 typedef struct {
 202   SWIG_CSharpExceptionArgumentCodes code;
 203   SWIG_CSharpExceptionArgumentCallback_t callback;
 204 } SWIG_CSharpExceptionArgument_t;
 205
 206 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 207   { SWIG_CSharpApplicationException, NULL },
 208   { SWIG_CSharpArithmeticException, NULL },
 209   { SWIG_CSharpDivideByZeroException, NULL },
 210   { SWIG_CSharpIndexOutOfRangeException, NULL },
 211   { SWIG_CSharpInvalidCastException, NULL },
 212   { SWIG_CSharpInvalidOperationException, NULL },
 213   { SWIG_CSharpIOException, NULL },
 214   { SWIG_CSharpNullReferenceException, NULL },
 215   { SWIG_CSharpOutOfMemoryException, NULL },
 216   { SWIG_CSharpOverflowException, NULL },
 217   { SWIG_CSharpSystemException, NULL }
 218 };
 219
 220 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 221   { SWIG_CSharpArgumentException, NULL },
 222   { SWIG_CSharpArgumentNullException, NULL },
 223   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 224 };
 225
 226 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 227   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 228   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 229     callback = SWIG_csharp_exceptions[code].callback;
 230   }
 231   callback(msg);
 232 }
 233
 234 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 235   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 236   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 237     callback = SWIG_csharp_exceptions_argument[code].callback;
 238   }
 239   callback(msg, param_name);
 240 }
 241
 242
 243 #ifdef __cplusplus
 244 extern "C"
 245 #endif
 246 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 247                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 248                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 249                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 250                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 251                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 253                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 254                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 255                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 256                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 257                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 258   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 269 }
 270
 271 #ifdef __cplusplus
 272 extern "C"
 273 #endif
 274 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 281 }
 282
 283
 284 /* Callback for returning strings to C# without leaking memory */
 285 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 286 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 287
 288
 289 #ifdef __cplusplus
 290 extern "C"
 291 #endif
 292 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 293   SWIG_csharp_string_callback = callback;
 294 }
 295
 296
 297 /* Contract support */
 298
 299 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 300
 301 /*  Errors in SWIG */
 302 #define  SWIG_UnknownError         -1
 303 #define  SWIG_IOError              -2
 304 #define  SWIG_RuntimeError         -3
 305 #define  SWIG_IndexError           -4
 306 #define  SWIG_TypeError            -5
 307 #define  SWIG_DivisionByZero       -6
 308 #define  SWIG_OverflowError        -7
 309 #define  SWIG_SyntaxError          -8
 310 #define  SWIG_ValueError           -9
 311 #define  SWIG_SystemError          -10
 312 #define  SWIG_AttributeError       -11
 313 #define  SWIG_MemoryError          -12
 314 #define  SWIG_NullReferenceError   -13
 315
 316
 317
 318 /* -----------------------------------------------------------------------------
 319  * director_common.swg
 320  *
 321  * This file contains support for director classes which is common between
 322  * languages.
 323  * ----------------------------------------------------------------------------- */
 324
 325 /*
 326   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 327   'Swig' namespace. This could be useful for multi-modules projects.
 328 */
 329 #ifdef SWIG_DIRECTOR_STATIC
 330 /* Force anonymous (static) namespace */
 331 #define Swig
 332 #endif
 333 /* -----------------------------------------------------------------------------
 334  * director.swg
 335  *
 336  * This file contains support for director classes so that C# proxy
 337  * methods can be called from C++.
 338  * ----------------------------------------------------------------------------- */
 339
 340 #if defined(DEBUG_DIRECTOR_OWNED)
 341 #include <iostream>
 342 #endif
 343 #include <string>
 344 #include <exception>
 345
 346 namespace Swig {
 347   /* Director base class - not currently used in C# directors */
 348   class Director {
 349   };
 350
 351   /* Base class for director exceptions */
 352   class DirectorException : public std::exception {
 353   protected:
 354     std::string swig_msg;
 355
 356   public:
 357     DirectorException(const char *msg) : swig_msg(msg) {
 358     }
 359
 360     DirectorException(const std::string &msg) : swig_msg(msg) {
 361     }
 362
 363     virtual ~DirectorException() throw() {
 364     }
 365
 366     const char *what() const throw() {
 367       return swig_msg.c_str();
 368     }
 369   };
 370
 371   /* Pure virtual method exception */
 372   class DirectorPureVirtualException : public DirectorException {
 373   public:
 374     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 375     }
 376   };
 377 }
 378
 379
 380 void SWIG_CSharpException(int code, const char *msg) {
 381   if (code == SWIG_ValueError) {
 382     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 383     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 384   } else {
 385     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 386     switch(code) {
 387     case SWIG_MemoryError:
 388       exception_code = SWIG_CSharpOutOfMemoryException;
 389       break;
 390     case SWIG_IndexError:
 391       exception_code = SWIG_CSharpIndexOutOfRangeException;
 392       break;
 393     case SWIG_DivisionByZero:
 394       exception_code = SWIG_CSharpDivideByZeroException;
 395       break;
 396     case SWIG_IOError:
 397       exception_code = SWIG_CSharpIOException;
 398       break;
 399     case SWIG_OverflowError:
 400       exception_code = SWIG_CSharpOverflowException;
 401       break;
 402     case SWIG_RuntimeError:
 403     case SWIG_TypeError:
 404     case SWIG_SyntaxError:
 405     case SWIG_SystemError:
 406     case SWIG_UnknownError:
 407     default:
 408       exception_code = SWIG_CSharpApplicationException;
 409       break;
 410     }
 411     SWIG_CSharpSetPendingException(exception_code, msg);
 412   }
 413 }
 414
 415
 416 #include <stdexcept>
 417
 418
 419 #define SWIGSTDCALL
 420
 421
 422 #include <dali/dali.h>
 423 #include <dali-toolkit/dali-toolkit.h>
 424
 425 #include <dali/devel-api/actors/actor-devel.h>
 426
 427 #include <dali/public-api/math/matrix.h>
 428 #include <dali/public-api/math/matrix3.h>
 429 #include <dali/public-api/math/viewport.h>
 430 #include <dali/public-api/object/property-key.h>
 431 #include <dali/devel-api/object/csharp-type-info.h>
 432 #include <dali/devel-api/object/csharp-type-registry.h>
 433
 434 #include <dali/public-api/adaptor-framework/timer.h>
 435 #include <dali/public-api/adaptor-framework/style-change.h>
 436 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 437 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 438
 439 #include <dali/devel-api/images/nine-patch-image.h>
 440
 441 #include <dali-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 445
 446 #include <dali-toolkit/devel-api/controls/control-devel.h>
 447 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 448 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 453 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 454 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 455 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 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/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.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_LOOP_COUNT_get() {
60051   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60052 }
60053
60054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60055   int jresult ;
60056   int result;
60057   {
60058     try
60059     {
60060       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60061     } catch (std::out_of_range& e) {
60062       {
60063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60064       };
60065     } catch (std::exception& e) {
60066       {
60067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60068       };
60069     } catch (Dali::DaliException e) {
60070       {
60071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60072       };
60073     } catch (...) {
60074       {
60075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60076       };
60077     }
60078   }
60079
60080   jresult = (int)result;
60081   return jresult;
60082 }
60083
60084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60085   int jresult ;
60086   int result;
60087   {
60088     try
60089     {
60090       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60091     } catch (std::out_of_range& e) {
60092       {
60093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60094       };
60095     } catch (std::exception& e) {
60096       {
60097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60098       };
60099     } catch (Dali::DaliException e) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60102       };
60103     } catch (...) {
60104       {
60105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60106       };
60107     }
60108   }
60109
60110   jresult = (int)result;
60111   return jresult;
60112 }
60113
60114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60115   int jresult ;
60116   int result;
60117
60118   {
60119     try {
60120       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60121     } catch (std::out_of_range& e) {
60122       {
60123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60124       };
60125     } catch (std::exception& e) {
60126       {
60127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60128       };
60129     } catch (Dali::DaliException e) {
60130       {
60131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60132       };
60133     } catch (...) {
60134       {
60135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60136       };
60137     }
60138   }
60139
60140   jresult = (int)result;
60141   return jresult;
60142 }
60143
60144
60145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60146   int jresult ;
60147   int result;
60148
60149   {
60150     try {
60151       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60152     } catch (std::out_of_range& e) {
60153       {
60154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60155       };
60156     } catch (std::exception& e) {
60157       {
60158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60159       };
60160     } catch (Dali::DaliException e) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60163       };
60164     } catch (...) {
60165       {
60166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60167       };
60168     }
60169   }
60170
60171   jresult = (int)result;
60172   return jresult;
60173 }
60174
60175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60176   int jresult ;
60177   int result;
60178   {
60179     try
60180     {
60181       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60182     } catch (std::out_of_range& e) {
60183       {
60184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60185       };
60186     } catch (std::exception& e) {
60187       {
60188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60189       };
60190     } catch (...) {
60191       {
60192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60193       };
60194     }
60195   }
60196   jresult = (int)result;
60197   return jresult;
60198 }
60199
60200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60201   int jresult ;
60202   int result;
60203   {
60204     try
60205     {
60206       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60207     } catch (std::out_of_range& e) {
60208       {
60209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (std::exception& e) {
60212       {
60213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (...) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60218       };
60219     }
60220   }
60221   jresult = (int)result;
60222   return jresult;
60223 }
60224
60225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60226   int jresult ;
60227   int result;
60228   {
60229     try
60230     {
60231       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60232     } catch (std::out_of_range& e) {
60233       {
60234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60235       };
60236     } catch (std::exception& e) {
60237       {
60238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60239       };
60240     } catch (...) {
60241       {
60242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60243       };
60244     }
60245   }
60246   jresult = (int)result;
60247   return jresult;
60248 }
60249
60250
60251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60252   int jresult ;
60253   int result;
60254   {
60255     try
60256     {
60257       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60258     } catch (std::out_of_range& e) {
60259       {
60260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60261       };
60262     } catch (std::exception& e) {
60263       {
60264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60265       };
60266     } catch (...) {
60267       {
60268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60269       };
60270     }
60271   }
60272   jresult = (int)result;
60273   return jresult;
60274 }
60275
60276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60277   int jresult ;
60278   int result;
60279   {
60280     try
60281     {
60282       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60283     } catch (std::out_of_range& e) {
60284       {
60285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60286       };
60287     } catch (std::exception& e) {
60288       {
60289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60290       };
60291     } catch (...) {
60292       {
60293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60294       };
60295     }
60296   }
60297   jresult = (int)result;
60298   return jresult;
60299 }
60300
60301
60302
60303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60304   int jresult ;
60305   int result;
60306
60307   {
60308     try {
60309       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60310     } catch (std::out_of_range& e) {
60311       {
60312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60313       };
60314     } catch (std::exception& e) {
60315       {
60316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60317       };
60318     } catch (Dali::DaliException e) {
60319       {
60320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60321       };
60322     } catch (...) {
60323       {
60324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60325       };
60326     }
60327   }
60328
60329   jresult = (int)result;
60330   return jresult;
60331 }
60332
60333
60334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60335   int jresult ;
60336   int result;
60337
60338   {
60339     try {
60340       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60341     } catch (std::out_of_range& e) {
60342       {
60343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60344       };
60345     } catch (std::exception& e) {
60346       {
60347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (Dali::DaliException e) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60352       };
60353     } catch (...) {
60354       {
60355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60356       };
60357     }
60358   }
60359
60360   jresult = (int)result;
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60366   int jresult ;
60367   int result;
60368
60369   {
60370     try {
60371       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60372     } catch (std::out_of_range& e) {
60373       {
60374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (std::exception& e) {
60377       {
60378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60379       };
60380     } catch (Dali::DaliException e) {
60381       {
60382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60383       };
60384     } catch (...) {
60385       {
60386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60387       };
60388     }
60389   }
60390
60391   jresult = (int)result;
60392   return jresult;
60393 }
60394
60395
60396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60397   int jresult ;
60398   int result;
60399
60400   {
60401     try {
60402       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60403     } catch (std::out_of_range& e) {
60404       {
60405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60406       };
60407     } catch (std::exception& e) {
60408       {
60409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (Dali::DaliException e) {
60412       {
60413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60414       };
60415     } catch (...) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60418       };
60419     }
60420   }
60421
60422   jresult = (int)result;
60423   return jresult;
60424 }
60425
60426
60427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60428   int jresult ;
60429   int result;
60430
60431   {
60432     try {
60433       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60434     } catch (std::out_of_range& e) {
60435       {
60436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60437       };
60438     } catch (std::exception& e) {
60439       {
60440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60441       };
60442     } catch (Dali::DaliException e) {
60443       {
60444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60445       };
60446     } catch (...) {
60447       {
60448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60449       };
60450     }
60451   }
60452
60453   jresult = (int)result;
60454   return jresult;
60455 }
60456
60457
60458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60459   int jresult ;
60460   int result;
60461
60462   {
60463     try {
60464       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60465     } catch (std::out_of_range& e) {
60466       {
60467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60468       };
60469     } catch (std::exception& e) {
60470       {
60471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60472       };
60473     } catch (Dali::DaliException e) {
60474       {
60475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60476       };
60477     } catch (...) {
60478       {
60479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60480       };
60481     }
60482   }
60483
60484   jresult = (int)result;
60485   return jresult;
60486 }
60487
60488
60489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60490   int jresult ;
60491   int result;
60492
60493   {
60494     try {
60495       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60496     } catch (std::out_of_range& e) {
60497       {
60498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60499       };
60500     } catch (std::exception& e) {
60501       {
60502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60503       };
60504     } catch (Dali::DaliException e) {
60505       {
60506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60507       };
60508     } catch (...) {
60509       {
60510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60511       };
60512     }
60513   }
60514
60515   jresult = (int)result;
60516   return jresult;
60517 }
60518
60519 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60520   int jresult ;
60521   int result;
60522
60523   {
60524     try {
60525       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60526     } catch (std::out_of_range& e) {
60527       {
60528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60529       };
60530     } catch (std::exception& e) {
60531       {
60532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60533       };
60534     } catch (...) {
60535       {
60536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60537       };
60538     }
60539   }
60540   jresult = (int)result;
60541   return jresult;
60542 }
60543
60544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60545   int jresult ;
60546   int result;
60547
60548   {
60549     try {
60550       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60551     } catch (std::out_of_range& e) {
60552       {
60553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (std::exception& e) {
60556       {
60557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (Dali::DaliException e) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569
60570   jresult = (int)result;
60571   return jresult;
60572 }
60573
60574
60575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60576   int jresult ;
60577   int result;
60578
60579   {
60580     try {
60581       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (Dali::DaliException e) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60593       };
60594     } catch (...) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60597       };
60598     }
60599   }
60600
60601   jresult = (int)result;
60602   return jresult;
60603 }
60604
60605
60606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60607   int jresult ;
60608   int result;
60609
60610   {
60611     try {
60612       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60613     } catch (std::out_of_range& e) {
60614       {
60615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (std::exception& e) {
60618       {
60619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (Dali::DaliException e) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60624       };
60625     } catch (...) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60628       };
60629     }
60630   }
60631
60632   jresult = (int)result;
60633   return jresult;
60634 }
60635
60636
60637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60638   int jresult ;
60639   int result;
60640
60641   {
60642     try {
60643       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60644     } catch (std::out_of_range& e) {
60645       {
60646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (std::exception& e) {
60649       {
60650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (Dali::DaliException e) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60659       };
60660     }
60661   }
60662
60663   jresult = (int)result;
60664   return jresult;
60665 }
60666
60667
60668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60669   int jresult ;
60670   int result;
60671
60672   {
60673     try {
60674       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (Dali::DaliException e) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60686       };
60687     } catch (...) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60690       };
60691     }
60692   }
60693
60694   jresult = (int)result;
60695   return jresult;
60696 }
60697
60698
60699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60700   int jresult ;
60701   int result;
60702
60703   {
60704     try {
60705       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60706     } catch (std::out_of_range& e) {
60707       {
60708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (std::exception& e) {
60711       {
60712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (Dali::DaliException e) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60717       };
60718     } catch (...) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60721       };
60722     }
60723   }
60724
60725   jresult = (int)result;
60726   return jresult;
60727 }
60728
60729
60730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60731   int jresult ;
60732   int result;
60733
60734   {
60735     try {
60736       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60737     } catch (std::out_of_range& e) {
60738       {
60739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (std::exception& e) {
60742       {
60743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (Dali::DaliException e) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60748       };
60749     } catch (...) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60752       };
60753     }
60754   }
60755
60756   jresult = (int)result;
60757   return jresult;
60758 }
60759
60760
60761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60762   int jresult ;
60763   int result;
60764
60765   {
60766     try {
60767       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (Dali::DaliException e) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60779       };
60780     } catch (...) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60783       };
60784     }
60785   }
60786
60787   jresult = (int)result;
60788   return jresult;
60789 }
60790
60791
60792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60793   int jresult ;
60794   int result;
60795
60796   {
60797     try {
60798       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60799     } catch (std::out_of_range& e) {
60800       {
60801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (std::exception& e) {
60804       {
60805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (Dali::DaliException e) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60810       };
60811     } catch (...) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60814       };
60815     }
60816   }
60817
60818   jresult = (int)result;
60819   return jresult;
60820 }
60821
60822
60823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60824   int jresult ;
60825   int result;
60826
60827   {
60828     try {
60829       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (Dali::DaliException e) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60845       };
60846     }
60847   }
60848
60849   jresult = (int)result;
60850   return jresult;
60851 }
60852
60853
60854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60855   int jresult ;
60856   int result;
60857
60858   {
60859     try {
60860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60861     } catch (std::out_of_range& e) {
60862       {
60863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (std::exception& e) {
60866       {
60867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (Dali::DaliException e) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60872       };
60873     } catch (...) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60876       };
60877     }
60878   }
60879
60880   jresult = (int)result;
60881   return jresult;
60882 }
60883
60884
60885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60886   int jresult ;
60887   int result;
60888
60889   {
60890     try {
60891       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60892     } catch (std::out_of_range& e) {
60893       {
60894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (std::exception& e) {
60897       {
60898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (Dali::DaliException e) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60903       };
60904     } catch (...) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60907       };
60908     }
60909   }
60910
60911   jresult = (int)result;
60912   return jresult;
60913 }
60914
60915
60916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60917   int jresult ;
60918   int result;
60919
60920   {
60921     try {
60922       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60923     } catch (std::out_of_range& e) {
60924       {
60925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (std::exception& e) {
60928       {
60929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (Dali::DaliException e) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941
60942   jresult = (int)result;
60943   return jresult;
60944 }
60945
60946
60947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60948   int jresult ;
60949   int result;
60950
60951   {
60952     try {
60953       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60954     } catch (std::out_of_range& e) {
60955       {
60956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (std::exception& e) {
60959       {
60960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (Dali::DaliException e) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60965       };
60966     } catch (...) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60969       };
60970     }
60971   }
60972
60973   jresult = (int)result;
60974   return jresult;
60975 }
60976
60977
60978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60979   int jresult ;
60980   int result;
60981
60982   {
60983     try {
60984       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60985     } catch (std::out_of_range& e) {
60986       {
60987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (std::exception& e) {
60990       {
60991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (Dali::DaliException e) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003
61004   jresult = (int)result;
61005   return jresult;
61006 }
61007
61008
61009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61010   int jresult ;
61011   int result;
61012
61013   {
61014     try {
61015       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61016     } catch (std::out_of_range& e) {
61017       {
61018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (std::exception& e) {
61021       {
61022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (Dali::DaliException e) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61031       };
61032     }
61033   }
61034
61035   jresult = (int)result;
61036   return jresult;
61037 }
61038
61039
61040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61041   int jresult ;
61042   int result;
61043
61044   {
61045     try {
61046       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61047     } catch (std::out_of_range& e) {
61048       {
61049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (std::exception& e) {
61052       {
61053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (Dali::DaliException e) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61058       };
61059     } catch (...) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61062       };
61063     }
61064   }
61065
61066   jresult = (int)result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61072   int jresult ;
61073   int result;
61074
61075   {
61076     try {
61077       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61078     } catch (std::out_of_range& e) {
61079       {
61080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (std::exception& e) {
61083       {
61084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (Dali::DaliException e) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096
61097   jresult = (int)result;
61098   return jresult;
61099 }
61100
61101
61102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61103   int jresult ;
61104   int result;
61105
61106   {
61107     try {
61108       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61109     } catch (std::out_of_range& e) {
61110       {
61111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (std::exception& e) {
61114       {
61115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (Dali::DaliException e) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127
61128   jresult = (int)result;
61129   return jresult;
61130 }
61131
61132
61133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61134   int jresult ;
61135   int result;
61136
61137   {
61138     try {
61139       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61140     } catch (std::out_of_range& e) {
61141       {
61142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61143       };
61144     } catch (std::exception& e) {
61145       {
61146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (Dali::DaliException e) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61151       };
61152     } catch (...) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61155       };
61156     }
61157   }
61158
61159   jresult = (int)result;
61160   return jresult;
61161 }
61162
61163
61164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61165   int jresult ;
61166   int result;
61167
61168   {
61169     try {
61170       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61171     } catch (std::out_of_range& e) {
61172       {
61173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (std::exception& e) {
61176       {
61177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (Dali::DaliException e) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61186       };
61187     }
61188   }
61189
61190   jresult = (int)result;
61191   return jresult;
61192 }
61193
61194
61195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61196   int jresult ;
61197   int result;
61198
61199   {
61200     try {
61201       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61202     } catch (std::out_of_range& e) {
61203       {
61204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61205       };
61206     } catch (std::exception& e) {
61207       {
61208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (Dali::DaliException e) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61213       };
61214     } catch (...) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61217       };
61218     }
61219   }
61220
61221   jresult = (int)result;
61222   return jresult;
61223 }
61224
61225
61226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61227   int jresult ;
61228   int result;
61229
61230   {
61231     try {
61232       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (Dali::DaliException e) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61248       };
61249     }
61250   }
61251
61252   jresult = (int)result;
61253   return jresult;
61254 }
61255
61256
61257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61258   int jresult ;
61259   int result;
61260
61261   {
61262     try {
61263       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61264     } catch (std::out_of_range& e) {
61265       {
61266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61267       };
61268     } catch (std::exception& e) {
61269       {
61270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61271       };
61272     } catch (Dali::DaliException e) {
61273       {
61274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61275       };
61276     } catch (...) {
61277       {
61278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61279       };
61280     }
61281   }
61282
61283   jresult = (int)result;
61284   return jresult;
61285 }
61286
61287
61288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61289   int jresult ;
61290   int result;
61291
61292   {
61293     try {
61294       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61295     } catch (std::out_of_range& e) {
61296       {
61297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61298       };
61299     } catch (std::exception& e) {
61300       {
61301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (Dali::DaliException e) {
61304       {
61305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61306       };
61307     } catch (...) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61310       };
61311     }
61312   }
61313
61314   jresult = (int)result;
61315   return jresult;
61316 }
61317
61318
61319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61320   int jresult ;
61321   int result;
61322
61323   {
61324     try {
61325       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61326     } catch (std::out_of_range& e) {
61327       {
61328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61329       };
61330     } catch (std::exception& e) {
61331       {
61332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61333       };
61334     } catch (Dali::DaliException e) {
61335       {
61336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61337       };
61338     } catch (...) {
61339       {
61340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61341       };
61342     }
61343   }
61344
61345   jresult = (int)result;
61346   return jresult;
61347 }
61348
61349
61350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61351   int jresult ;
61352   int result;
61353
61354   {
61355     try {
61356       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61357     } catch (std::out_of_range& e) {
61358       {
61359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61360       };
61361     } catch (std::exception& e) {
61362       {
61363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (Dali::DaliException e) {
61366       {
61367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61368       };
61369     } catch (...) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61372       };
61373     }
61374   }
61375
61376   jresult = (int)result;
61377   return jresult;
61378 }
61379
61380
61381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61382   int jresult ;
61383   int result;
61384
61385   {
61386     try {
61387       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (Dali::DaliException e) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61399       };
61400     } catch (...) {
61401       {
61402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61403       };
61404     }
61405   }
61406
61407   jresult = (int)result;
61408   return jresult;
61409 }
61410
61411
61412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61413   void * jresult ;
61414   Dali::Toolkit::Builder *result = 0 ;
61415
61416   {
61417     try {
61418       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61419     } catch (std::out_of_range& e) {
61420       {
61421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61422       };
61423     } catch (std::exception& e) {
61424       {
61425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61426       };
61427     } catch (Dali::DaliException e) {
61428       {
61429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61430       };
61431     } catch (...) {
61432       {
61433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61434       };
61435     }
61436   }
61437
61438   jresult = (void *)result;
61439   return jresult;
61440 }
61441
61442
61443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61444   void * jresult ;
61445   Dali::Toolkit::Builder result;
61446
61447   {
61448     try {
61449       result = Dali::Toolkit::Builder::New();
61450     } catch (std::out_of_range& e) {
61451       {
61452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (std::exception& e) {
61455       {
61456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61457       };
61458     } catch (Dali::DaliException e) {
61459       {
61460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61461       };
61462     } catch (...) {
61463       {
61464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61465       };
61466     }
61467   }
61468
61469   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61470   return jresult;
61471 }
61472
61473
61474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61475   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61476
61477   arg1 = (Dali::Toolkit::Builder *)jarg1;
61478   {
61479     try {
61480       delete arg1;
61481     } catch (std::out_of_range& e) {
61482       {
61483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61484       };
61485     } catch (std::exception& e) {
61486       {
61487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61488       };
61489     } catch (Dali::DaliException e) {
61490       {
61491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61492       };
61493     } catch (...) {
61494       {
61495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61496       };
61497     }
61498   }
61499
61500 }
61501
61502
61503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61504   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61505   std::string *arg2 = 0 ;
61506   Dali::Toolkit::Builder::UIFormat arg3 ;
61507
61508   arg1 = (Dali::Toolkit::Builder *)jarg1;
61509   if (!jarg2) {
61510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61511     return ;
61512   }
61513   std::string arg2_str(jarg2);
61514   arg2 = &arg2_str;
61515   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61516   {
61517     try {
61518       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61519     } catch (std::out_of_range& e) {
61520       {
61521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (std::exception& e) {
61524       {
61525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61526       };
61527     } catch (Dali::DaliException e) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61530       };
61531     } catch (...) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61534       };
61535     }
61536   }
61537
61538
61539   //argout typemap for const std::string&
61540
61541 }
61542
61543
61544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61545   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61546   std::string *arg2 = 0 ;
61547
61548   arg1 = (Dali::Toolkit::Builder *)jarg1;
61549   if (!jarg2) {
61550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61551     return ;
61552   }
61553   std::string arg2_str(jarg2);
61554   arg2 = &arg2_str;
61555   {
61556     try {
61557       (arg1)->LoadFromString((std::string const &)*arg2);
61558     } catch (std::out_of_range& e) {
61559       {
61560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61561       };
61562     } catch (std::exception& e) {
61563       {
61564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61565       };
61566     } catch (Dali::DaliException e) {
61567       {
61568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61569       };
61570     } catch (...) {
61571       {
61572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61573       };
61574     }
61575   }
61576
61577
61578   //argout typemap for const std::string&
61579
61580 }
61581
61582
61583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61584   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61585   Dali::Property::Map *arg2 = 0 ;
61586
61587   arg1 = (Dali::Toolkit::Builder *)jarg1;
61588   arg2 = (Dali::Property::Map *)jarg2;
61589   if (!arg2) {
61590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61591     return ;
61592   }
61593   {
61594     try {
61595       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61596     } catch (std::out_of_range& e) {
61597       {
61598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61599       };
61600     } catch (std::exception& e) {
61601       {
61602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61603       };
61604     } catch (Dali::DaliException e) {
61605       {
61606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61607       };
61608     } catch (...) {
61609       {
61610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61611       };
61612     }
61613   }
61614
61615 }
61616
61617
61618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61619   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61620   std::string *arg2 = 0 ;
61621   Dali::Property::Value *arg3 = 0 ;
61622
61623   arg1 = (Dali::Toolkit::Builder *)jarg1;
61624   if (!jarg2) {
61625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61626     return ;
61627   }
61628   std::string arg2_str(jarg2);
61629   arg2 = &arg2_str;
61630   arg3 = (Dali::Property::Value *)jarg3;
61631   if (!arg3) {
61632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61633     return ;
61634   }
61635   {
61636     try {
61637       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61638     } catch (std::out_of_range& e) {
61639       {
61640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61641       };
61642     } catch (std::exception& e) {
61643       {
61644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61645       };
61646     } catch (Dali::DaliException e) {
61647       {
61648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61649       };
61650     } catch (...) {
61651       {
61652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61653       };
61654     }
61655   }
61656
61657
61658   //argout typemap for const std::string&
61659
61660 }
61661
61662
61663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61664   void * jresult ;
61665   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61666   Dali::Property::Map *result = 0 ;
61667
61668   arg1 = (Dali::Toolkit::Builder *)jarg1;
61669   {
61670     try {
61671       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61672     } catch (std::out_of_range& e) {
61673       {
61674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61675       };
61676     } catch (std::exception& e) {
61677       {
61678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61679       };
61680     } catch (Dali::DaliException e) {
61681       {
61682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61683       };
61684     } catch (...) {
61685       {
61686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61687       };
61688     }
61689   }
61690
61691   jresult = (void *)result;
61692   return jresult;
61693 }
61694
61695
61696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61697   void * jresult ;
61698   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61699   std::string *arg2 = 0 ;
61700   Dali::Property::Value *result = 0 ;
61701
61702   arg1 = (Dali::Toolkit::Builder *)jarg1;
61703   if (!jarg2) {
61704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61705     return 0;
61706   }
61707   std::string arg2_str(jarg2);
61708   arg2 = &arg2_str;
61709   {
61710     try {
61711       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61712     } catch (std::out_of_range& e) {
61713       {
61714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61715       };
61716     } catch (std::exception& e) {
61717       {
61718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61719       };
61720     } catch (Dali::DaliException e) {
61721       {
61722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61723       };
61724     } catch (...) {
61725       {
61726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61727       };
61728     }
61729   }
61730
61731   jresult = (void *)result;
61732
61733   //argout typemap for const std::string&
61734
61735   return jresult;
61736 }
61737
61738
61739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61740   void * jresult ;
61741   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61742   std::string *arg2 = 0 ;
61743   Dali::Animation result;
61744
61745   arg1 = (Dali::Toolkit::Builder *)jarg1;
61746   if (!jarg2) {
61747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61748     return 0;
61749   }
61750   std::string arg2_str(jarg2);
61751   arg2 = &arg2_str;
61752   {
61753     try {
61754       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61755     } catch (std::out_of_range& e) {
61756       {
61757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61758       };
61759     } catch (std::exception& e) {
61760       {
61761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61762       };
61763     } catch (Dali::DaliException e) {
61764       {
61765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61766       };
61767     } catch (...) {
61768       {
61769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61770       };
61771     }
61772   }
61773
61774   jresult = new Dali::Animation((const Dali::Animation &)result);
61775
61776   //argout typemap for const std::string&
61777
61778   return jresult;
61779 }
61780
61781
61782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61783   void * jresult ;
61784   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61785   std::string *arg2 = 0 ;
61786   Dali::Property::Map *arg3 = 0 ;
61787   Dali::Animation result;
61788
61789   arg1 = (Dali::Toolkit::Builder *)jarg1;
61790   if (!jarg2) {
61791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61792     return 0;
61793   }
61794   std::string arg2_str(jarg2);
61795   arg2 = &arg2_str;
61796   arg3 = (Dali::Property::Map *)jarg3;
61797   if (!arg3) {
61798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61799     return 0;
61800   }
61801   {
61802     try {
61803       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61804     } catch (std::out_of_range& e) {
61805       {
61806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61807       };
61808     } catch (std::exception& e) {
61809       {
61810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61811       };
61812     } catch (Dali::DaliException e) {
61813       {
61814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61815       };
61816     } catch (...) {
61817       {
61818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61819       };
61820     }
61821   }
61822
61823   jresult = new Dali::Animation((const Dali::Animation &)result);
61824
61825   //argout typemap for const std::string&
61826
61827   return jresult;
61828 }
61829
61830
61831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61832   void * jresult ;
61833   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61834   std::string *arg2 = 0 ;
61835   Dali::Actor arg3 ;
61836   Dali::Actor *argp3 ;
61837   Dali::Animation result;
61838
61839   arg1 = (Dali::Toolkit::Builder *)jarg1;
61840   if (!jarg2) {
61841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61842     return 0;
61843   }
61844   std::string arg2_str(jarg2);
61845   arg2 = &arg2_str;
61846   argp3 = (Dali::Actor *)jarg3;
61847   if (!argp3) {
61848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61849     return 0;
61850   }
61851   arg3 = *argp3;
61852   {
61853     try {
61854       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61855     } catch (std::out_of_range& e) {
61856       {
61857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61858       };
61859     } catch (std::exception& e) {
61860       {
61861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61862       };
61863     } catch (Dali::DaliException e) {
61864       {
61865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61866       };
61867     } catch (...) {
61868       {
61869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61870       };
61871     }
61872   }
61873
61874   jresult = new Dali::Animation((const Dali::Animation &)result);
61875
61876   //argout typemap for const std::string&
61877
61878   return jresult;
61879 }
61880
61881
61882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61883   void * jresult ;
61884   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61885   std::string *arg2 = 0 ;
61886   Dali::Property::Map *arg3 = 0 ;
61887   Dali::Actor arg4 ;
61888   Dali::Actor *argp4 ;
61889   Dali::Animation result;
61890
61891   arg1 = (Dali::Toolkit::Builder *)jarg1;
61892   if (!jarg2) {
61893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61894     return 0;
61895   }
61896   std::string arg2_str(jarg2);
61897   arg2 = &arg2_str;
61898   arg3 = (Dali::Property::Map *)jarg3;
61899   if (!arg3) {
61900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61901     return 0;
61902   }
61903   argp4 = (Dali::Actor *)jarg4;
61904   if (!argp4) {
61905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61906     return 0;
61907   }
61908   arg4 = *argp4;
61909   {
61910     try {
61911       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61912     } catch (std::out_of_range& e) {
61913       {
61914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61915       };
61916     } catch (std::exception& e) {
61917       {
61918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61919       };
61920     } catch (Dali::DaliException e) {
61921       {
61922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61923       };
61924     } catch (...) {
61925       {
61926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61927       };
61928     }
61929   }
61930
61931   jresult = new Dali::Animation((const Dali::Animation &)result);
61932
61933   //argout typemap for const std::string&
61934
61935   return jresult;
61936 }
61937
61938
61939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61940   void * jresult ;
61941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61942   std::string *arg2 = 0 ;
61943   Dali::BaseHandle result;
61944
61945   arg1 = (Dali::Toolkit::Builder *)jarg1;
61946   if (!jarg2) {
61947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61948     return 0;
61949   }
61950   std::string arg2_str(jarg2);
61951   arg2 = &arg2_str;
61952   {
61953     try {
61954       result = (arg1)->Create((std::string const &)*arg2);
61955     } catch (std::out_of_range& e) {
61956       {
61957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61958       };
61959     } catch (std::exception& e) {
61960       {
61961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61962       };
61963     } catch (Dali::DaliException e) {
61964       {
61965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61966       };
61967     } catch (...) {
61968       {
61969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61970       };
61971     }
61972   }
61973
61974   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61975
61976   //argout typemap for const std::string&
61977
61978   return jresult;
61979 }
61980
61981
61982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61983   void * jresult ;
61984   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61985   std::string *arg2 = 0 ;
61986   Dali::Property::Map *arg3 = 0 ;
61987   Dali::BaseHandle result;
61988
61989   arg1 = (Dali::Toolkit::Builder *)jarg1;
61990   if (!jarg2) {
61991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61992     return 0;
61993   }
61994   std::string arg2_str(jarg2);
61995   arg2 = &arg2_str;
61996   arg3 = (Dali::Property::Map *)jarg3;
61997   if (!arg3) {
61998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61999     return 0;
62000   }
62001   {
62002     try {
62003       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62004     } catch (std::out_of_range& e) {
62005       {
62006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62007       };
62008     } catch (std::exception& e) {
62009       {
62010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62011       };
62012     } catch (Dali::DaliException e) {
62013       {
62014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62015       };
62016     } catch (...) {
62017       {
62018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62019       };
62020     }
62021   }
62022
62023   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62024
62025   //argout typemap for const std::string&
62026
62027   return jresult;
62028 }
62029
62030
62031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62032   void * jresult ;
62033   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62034   std::string *arg2 = 0 ;
62035   Dali::BaseHandle result;
62036
62037   arg1 = (Dali::Toolkit::Builder *)jarg1;
62038   if (!jarg2) {
62039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62040     return 0;
62041   }
62042   std::string arg2_str(jarg2);
62043   arg2 = &arg2_str;
62044   {
62045     try {
62046       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62047     } catch (std::out_of_range& e) {
62048       {
62049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62050       };
62051     } catch (std::exception& e) {
62052       {
62053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62054       };
62055     } catch (Dali::DaliException e) {
62056       {
62057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62058       };
62059     } catch (...) {
62060       {
62061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62062       };
62063     }
62064   }
62065
62066   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62067
62068   //argout typemap for const std::string&
62069
62070   return jresult;
62071 }
62072
62073
62074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62075   unsigned int jresult ;
62076   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62077   std::string *arg2 = 0 ;
62078   Dali::Handle *arg3 = 0 ;
62079   bool result;
62080
62081   arg1 = (Dali::Toolkit::Builder *)jarg1;
62082   if (!jarg2) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62084     return 0;
62085   }
62086   std::string arg2_str(jarg2);
62087   arg2 = &arg2_str;
62088   arg3 = (Dali::Handle *)jarg3;
62089   if (!arg3) {
62090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62091     return 0;
62092   }
62093   {
62094     try {
62095       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62096     } catch (std::out_of_range& e) {
62097       {
62098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62099       };
62100     } catch (std::exception& e) {
62101       {
62102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62103       };
62104     } catch (Dali::DaliException e) {
62105       {
62106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62107       };
62108     } catch (...) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62111       };
62112     }
62113   }
62114
62115   jresult = result;
62116
62117   //argout typemap for const std::string&
62118
62119   return jresult;
62120 }
62121
62122
62123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62124   unsigned int jresult ;
62125   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62126   Dali::Handle *arg2 = 0 ;
62127   std::string *arg3 = 0 ;
62128   bool result;
62129
62130   arg1 = (Dali::Toolkit::Builder *)jarg1;
62131   arg2 = (Dali::Handle *)jarg2;
62132   if (!arg2) {
62133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62134     return 0;
62135   }
62136   if (!jarg3) {
62137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62138     return 0;
62139   }
62140   std::string arg3_str(jarg3);
62141   arg3 = &arg3_str;
62142   {
62143     try {
62144       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62145     } catch (std::out_of_range& e) {
62146       {
62147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62148       };
62149     } catch (std::exception& e) {
62150       {
62151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62152       };
62153     } catch (Dali::DaliException e) {
62154       {
62155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62156       };
62157     } catch (...) {
62158       {
62159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62160       };
62161     }
62162   }
62163
62164   jresult = result;
62165
62166   //argout typemap for const std::string&
62167
62168   return jresult;
62169 }
62170
62171
62172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62173   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62174   Dali::Actor arg2 ;
62175   Dali::Actor *argp2 ;
62176
62177   arg1 = (Dali::Toolkit::Builder *)jarg1;
62178   argp2 = (Dali::Actor *)jarg2;
62179   if (!argp2) {
62180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62181     return ;
62182   }
62183   arg2 = *argp2;
62184   {
62185     try {
62186       (arg1)->AddActors(arg2);
62187     } catch (std::out_of_range& e) {
62188       {
62189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62190       };
62191     } catch (std::exception& e) {
62192       {
62193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62194       };
62195     } catch (Dali::DaliException e) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62198       };
62199     } catch (...) {
62200       {
62201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62202       };
62203     }
62204   }
62205
62206 }
62207
62208
62209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62210   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62211   std::string *arg2 = 0 ;
62212   Dali::Actor arg3 ;
62213   Dali::Actor *argp3 ;
62214
62215   arg1 = (Dali::Toolkit::Builder *)jarg1;
62216   if (!jarg2) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62218     return ;
62219   }
62220   std::string arg2_str(jarg2);
62221   arg2 = &arg2_str;
62222   argp3 = (Dali::Actor *)jarg3;
62223   if (!argp3) {
62224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62225     return ;
62226   }
62227   arg3 = *argp3;
62228   {
62229     try {
62230       (arg1)->AddActors((std::string const &)*arg2,arg3);
62231     } catch (std::out_of_range& e) {
62232       {
62233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62234       };
62235     } catch (std::exception& e) {
62236       {
62237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62238       };
62239     } catch (Dali::DaliException e) {
62240       {
62241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62242       };
62243     } catch (...) {
62244       {
62245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62246       };
62247     }
62248   }
62249
62250
62251   //argout typemap for const std::string&
62252
62253 }
62254
62255
62256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62257   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62258   std::string *arg2 = 0 ;
62259
62260   arg1 = (Dali::Toolkit::Builder *)jarg1;
62261   if (!jarg2) {
62262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62263     return ;
62264   }
62265   std::string arg2_str(jarg2);
62266   arg2 = &arg2_str;
62267   {
62268     try {
62269       (arg1)->CreateRenderTask((std::string const &)*arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (Dali::DaliException e) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62281       };
62282     } catch (...) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62285       };
62286     }
62287   }
62288
62289
62290   //argout typemap for const std::string&
62291
62292 }
62293
62294
62295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62296   void * jresult ;
62297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62298   std::string *arg2 = 0 ;
62299   Dali::FrameBufferImage result;
62300
62301   arg1 = (Dali::Toolkit::Builder *)jarg1;
62302   if (!jarg2) {
62303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62304     return 0;
62305   }
62306   std::string arg2_str(jarg2);
62307   arg2 = &arg2_str;
62308   {
62309     try {
62310       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62311     } catch (std::out_of_range& e) {
62312       {
62313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62314       };
62315     } catch (std::exception& e) {
62316       {
62317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62318       };
62319     } catch (Dali::DaliException e) {
62320       {
62321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62322       };
62323     } catch (...) {
62324       {
62325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62326       };
62327     }
62328   }
62329
62330   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62331
62332   //argout typemap for const std::string&
62333
62334   return jresult;
62335 }
62336
62337
62338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62339   void * jresult ;
62340   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62341   std::string *arg2 = 0 ;
62342   Dali::Path result;
62343
62344   arg1 = (Dali::Toolkit::Builder *)jarg1;
62345   if (!jarg2) {
62346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62347     return 0;
62348   }
62349   std::string arg2_str(jarg2);
62350   arg2 = &arg2_str;
62351   {
62352     try {
62353       result = (arg1)->GetPath((std::string const &)*arg2);
62354     } catch (std::out_of_range& e) {
62355       {
62356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62357       };
62358     } catch (std::exception& e) {
62359       {
62360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62361       };
62362     } catch (Dali::DaliException e) {
62363       {
62364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62365       };
62366     } catch (...) {
62367       {
62368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62369       };
62370     }
62371   }
62372
62373   jresult = new Dali::Path((const Dali::Path &)result);
62374
62375   //argout typemap for const std::string&
62376
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62382   void * jresult ;
62383   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62384   std::string *arg2 = 0 ;
62385   Dali::PathConstrainer result;
62386
62387   arg1 = (Dali::Toolkit::Builder *)jarg1;
62388   if (!jarg2) {
62389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62390     return 0;
62391   }
62392   std::string arg2_str(jarg2);
62393   arg2 = &arg2_str;
62394   {
62395     try {
62396       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62397     } catch (std::out_of_range& e) {
62398       {
62399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (std::exception& e) {
62402       {
62403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62404       };
62405     } catch (Dali::DaliException e) {
62406       {
62407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62408       };
62409     } catch (...) {
62410       {
62411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62412       };
62413     }
62414   }
62415
62416   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62417
62418   //argout typemap for const std::string&
62419
62420   return jresult;
62421 }
62422
62423
62424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62425   void * jresult ;
62426   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62427   std::string *arg2 = 0 ;
62428   Dali::LinearConstrainer result;
62429
62430   arg1 = (Dali::Toolkit::Builder *)jarg1;
62431   if (!jarg2) {
62432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62433     return 0;
62434   }
62435   std::string arg2_str(jarg2);
62436   arg2 = &arg2_str;
62437   {
62438     try {
62439       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62440     } catch (std::out_of_range& e) {
62441       {
62442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62443       };
62444     } catch (std::exception& e) {
62445       {
62446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62447       };
62448     } catch (Dali::DaliException e) {
62449       {
62450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62451       };
62452     } catch (...) {
62453       {
62454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62455       };
62456     }
62457   }
62458
62459   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62460
62461   //argout typemap for const std::string&
62462
62463   return jresult;
62464 }
62465
62466
62467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62468   void * jresult ;
62469   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62470   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62471
62472   arg1 = (Dali::Toolkit::Builder *)jarg1;
62473   {
62474     try {
62475       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62483       };
62484     } catch (Dali::DaliException e) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62491       };
62492     }
62493   }
62494
62495   jresult = (void *)result;
62496   return jresult;
62497 }
62498
62499
62500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62501   void * jresult ;
62502   Dali::Toolkit::TransitionData *result = 0 ;
62503
62504   {
62505     try {
62506       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62507     } catch (std::out_of_range& e) {
62508       {
62509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62510       };
62511     } catch (std::exception& e) {
62512       {
62513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62514       };
62515     } catch (Dali::DaliException e) {
62516       {
62517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62518       };
62519     } catch (...) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62522       };
62523     }
62524   }
62525
62526   jresult = (void *)result;
62527   return jresult;
62528 }
62529
62530
62531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62532   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62533
62534   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62535   {
62536     try {
62537       delete arg1;
62538     } catch (std::out_of_range& e) {
62539       {
62540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62541       };
62542     } catch (std::exception& e) {
62543       {
62544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62545       };
62546     } catch (Dali::DaliException e) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62549       };
62550     } catch (...) {
62551       {
62552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62553       };
62554     }
62555   }
62556
62557 }
62558
62559
62560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62561   void * jresult ;
62562   Dali::Property::Map *arg1 = 0 ;
62563   Dali::Toolkit::TransitionData result;
62564
62565   arg1 = (Dali::Property::Map *)jarg1;
62566   if (!arg1) {
62567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62568     return 0;
62569   }
62570   {
62571     try {
62572       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62573     } catch (std::out_of_range& e) {
62574       {
62575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (std::exception& e) {
62578       {
62579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62580       };
62581     } catch (Dali::DaliException e) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62584       };
62585     } catch (...) {
62586       {
62587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62588       };
62589     }
62590   }
62591
62592   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62593   return jresult;
62594 }
62595
62596
62597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62598   void * jresult ;
62599   Dali::Property::Array *arg1 = 0 ;
62600   Dali::Toolkit::TransitionData result;
62601
62602   arg1 = (Dali::Property::Array *)jarg1;
62603   if (!arg1) {
62604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62605     return 0;
62606   }
62607   {
62608     try {
62609       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62610     } catch (std::out_of_range& e) {
62611       {
62612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (std::exception& e) {
62615       {
62616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62617       };
62618     } catch (Dali::DaliException e) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62621       };
62622     } catch (...) {
62623       {
62624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62625       };
62626     }
62627   }
62628
62629   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62630   return jresult;
62631 }
62632
62633
62634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62635   void * jresult ;
62636   Dali::BaseHandle arg1 ;
62637   Dali::BaseHandle *argp1 ;
62638   Dali::Toolkit::TransitionData result;
62639
62640   argp1 = (Dali::BaseHandle *)jarg1;
62641   if (!argp1) {
62642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62643     return 0;
62644   }
62645   arg1 = *argp1;
62646   {
62647     try {
62648       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62649     } catch (std::out_of_range& e) {
62650       {
62651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (std::exception& e) {
62654       {
62655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62656       };
62657     } catch (Dali::DaliException e) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62660       };
62661     } catch (...) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62664       };
62665     }
62666   }
62667
62668   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62669   return jresult;
62670 }
62671
62672
62673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62674   void * jresult ;
62675   Dali::Toolkit::TransitionData *arg1 = 0 ;
62676   Dali::Toolkit::TransitionData *result = 0 ;
62677
62678   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62679   if (!arg1) {
62680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62681     return 0;
62682   }
62683   {
62684     try {
62685       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62686     } catch (std::out_of_range& e) {
62687       {
62688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (std::exception& e) {
62691       {
62692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62693       };
62694     } catch (Dali::DaliException e) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62697       };
62698     } catch (...) {
62699       {
62700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62701       };
62702     }
62703   }
62704
62705   jresult = (void *)result;
62706   return jresult;
62707 }
62708
62709
62710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62711   void * jresult ;
62712   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62713   Dali::Toolkit::TransitionData *arg2 = 0 ;
62714   Dali::Toolkit::TransitionData *result = 0 ;
62715
62716   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62717   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62718   if (!arg2) {
62719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62720     return 0;
62721   }
62722   {
62723     try {
62724       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62725     } catch (std::out_of_range& e) {
62726       {
62727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62728       };
62729     } catch (std::exception& e) {
62730       {
62731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62732       };
62733     } catch (Dali::DaliException e) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62736       };
62737     } catch (...) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62740       };
62741     }
62742   }
62743
62744   jresult = (void *)result;
62745   return jresult;
62746 }
62747
62748
62749 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62750   unsigned long jresult ;
62751   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62752   size_t result;
62753
62754   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62755   {
62756     try {
62757       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62758     } catch (std::out_of_range& e) {
62759       {
62760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (std::exception& e) {
62763       {
62764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62765       };
62766     } catch (Dali::DaliException e) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62769       };
62770     } catch (...) {
62771       {
62772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62773       };
62774     }
62775   }
62776
62777   jresult = (unsigned long)result;
62778   return jresult;
62779 }
62780
62781
62782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62783   void * jresult ;
62784   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62785   size_t arg2 ;
62786   Dali::Property::Map result;
62787
62788   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62789   arg2 = (size_t)jarg2;
62790   {
62791     try {
62792       result = (arg1)->GetAnimatorAt(arg2);
62793     } catch (std::out_of_range& e) {
62794       {
62795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (std::exception& e) {
62798       {
62799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (Dali::DaliException e) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62804       };
62805     } catch (...) {
62806       {
62807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62808       };
62809     }
62810   }
62811
62812   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62813   return jresult;
62814 }
62815
62816
62817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62818   void * jresult ;
62819   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62820   Dali::Toolkit::TransitionData *result = 0 ;
62821
62822   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62823   {
62824     try {
62825       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
62826     } catch (std::out_of_range& e) {
62827       {
62828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (std::exception& e) {
62831       {
62832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (Dali::DaliException e) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62837       };
62838     } catch (...) {
62839       {
62840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62841       };
62842     }
62843   }
62844
62845   jresult = (void *)result;
62846   return jresult;
62847 }
62848
62849
62850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62851   int jresult ;
62852   int result;
62853
62854   {
62855     try {
62856       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62857     } catch (std::out_of_range& e) {
62858       {
62859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62860       };
62861     } catch (std::exception& e) {
62862       {
62863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62864       };
62865     } catch (Dali::DaliException e) {
62866       {
62867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62868       };
62869     } catch (...) {
62870       {
62871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62872       };
62873     }
62874   }
62875
62876   jresult = (int)result;
62877   return jresult;
62878 }
62879
62880
62881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62882   int jresult ;
62883   int result;
62884
62885   {
62886     try {
62887       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62888     } catch (std::out_of_range& e) {
62889       {
62890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62891       };
62892     } catch (std::exception& e) {
62893       {
62894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62895       };
62896     } catch (Dali::DaliException e) {
62897       {
62898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62899       };
62900     } catch (...) {
62901       {
62902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62903       };
62904     }
62905   }
62906
62907   jresult = (int)result;
62908   return jresult;
62909 }
62910
62911
62912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62913   int jresult ;
62914   int result;
62915
62916   {
62917     try {
62918       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62919     } catch (std::out_of_range& e) {
62920       {
62921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62922       };
62923     } catch (std::exception& e) {
62924       {
62925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62926       };
62927     } catch (Dali::DaliException e) {
62928       {
62929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62930       };
62931     } catch (...) {
62932       {
62933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62934       };
62935     }
62936   }
62937
62938   jresult = (int)result;
62939   return jresult;
62940 }
62941
62942
62943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62944   int jresult ;
62945   int result;
62946
62947   {
62948     try {
62949       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62950     } catch (std::out_of_range& e) {
62951       {
62952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (std::exception& e) {
62955       {
62956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62957       };
62958     } catch (Dali::DaliException e) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62961       };
62962     } catch (...) {
62963       {
62964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62965       };
62966     }
62967   }
62968
62969   jresult = (int)result;
62970   return jresult;
62971 }
62972
62973
62974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62975   int jresult ;
62976   int result;
62977
62978   {
62979     try {
62980       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62981     } catch (std::out_of_range& e) {
62982       {
62983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62984       };
62985     } catch (std::exception& e) {
62986       {
62987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62988       };
62989     } catch (Dali::DaliException e) {
62990       {
62991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62992       };
62993     } catch (...) {
62994       {
62995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62996       };
62997     }
62998   }
62999
63000   jresult = (int)result;
63001   return jresult;
63002 }
63003
63004
63005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63006   int jresult ;
63007   int result;
63008
63009   {
63010     try {
63011       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63012     } catch (std::out_of_range& e) {
63013       {
63014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63015       };
63016     } catch (std::exception& e) {
63017       {
63018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63019       };
63020     } catch (Dali::DaliException e) {
63021       {
63022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63023       };
63024     } catch (...) {
63025       {
63026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63027       };
63028     }
63029   }
63030
63031   jresult = (int)result;
63032   return jresult;
63033 }
63034
63035
63036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63037   int jresult ;
63038   int result;
63039
63040   {
63041     try {
63042       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63043     } catch (std::out_of_range& e) {
63044       {
63045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63046       };
63047     } catch (std::exception& e) {
63048       {
63049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63050       };
63051     } catch (Dali::DaliException e) {
63052       {
63053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63054       };
63055     } catch (...) {
63056       {
63057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63058       };
63059     }
63060   }
63061
63062   jresult = (int)result;
63063   return jresult;
63064 }
63065
63066
63067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63068   int jresult ;
63069   int result;
63070
63071   {
63072     try {
63073       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63074     } catch (std::out_of_range& e) {
63075       {
63076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63077       };
63078     } catch (std::exception& e) {
63079       {
63080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (Dali::DaliException e) {
63083       {
63084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63085       };
63086     } catch (...) {
63087       {
63088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63089       };
63090     }
63091   }
63092
63093   jresult = (int)result;
63094   return jresult;
63095 }
63096
63097
63098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63099   int jresult ;
63100   int result;
63101
63102   {
63103     try {
63104       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63105     } catch (std::out_of_range& e) {
63106       {
63107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63108       };
63109     } catch (std::exception& e) {
63110       {
63111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63112       };
63113     } catch (Dali::DaliException e) {
63114       {
63115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63120       };
63121     }
63122   }
63123
63124   jresult = (int)result;
63125   return jresult;
63126 }
63127
63128
63129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63130   int jresult ;
63131   int result;
63132
63133   {
63134     try {
63135       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63143       };
63144     } catch (Dali::DaliException e) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63147       };
63148     } catch (...) {
63149       {
63150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63151       };
63152     }
63153   }
63154
63155   jresult = (int)result;
63156   return jresult;
63157 }
63158
63159
63160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63161   int jresult ;
63162   int result;
63163
63164   {
63165     try {
63166       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63167     } catch (std::out_of_range& e) {
63168       {
63169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63170       };
63171     } catch (std::exception& e) {
63172       {
63173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63174       };
63175     } catch (Dali::DaliException e) {
63176       {
63177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63178       };
63179     } catch (...) {
63180       {
63181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63182       };
63183     }
63184   }
63185
63186   jresult = (int)result;
63187   return jresult;
63188 }
63189
63190
63191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63192   int jresult ;
63193   int result;
63194
63195   {
63196     try {
63197       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63198     } catch (std::out_of_range& e) {
63199       {
63200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (std::exception& e) {
63203       {
63204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63205       };
63206     } catch (Dali::DaliException e) {
63207       {
63208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63209       };
63210     } catch (...) {
63211       {
63212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63213       };
63214     }
63215   }
63216
63217   jresult = (int)result;
63218   return jresult;
63219 }
63220
63221
63222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63223   int jresult ;
63224   int result;
63225
63226   {
63227     try {
63228       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63229     } catch (std::out_of_range& e) {
63230       {
63231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63232       };
63233     } catch (std::exception& e) {
63234       {
63235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63236       };
63237     } catch (Dali::DaliException e) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63240       };
63241     } catch (...) {
63242       {
63243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63244       };
63245     }
63246   }
63247
63248   jresult = (int)result;
63249   return jresult;
63250 }
63251
63252
63253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63254   int jresult ;
63255   int result;
63256
63257   {
63258     try {
63259       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63260     } catch (std::out_of_range& e) {
63261       {
63262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63263       };
63264     } catch (std::exception& e) {
63265       {
63266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63267       };
63268     } catch (Dali::DaliException e) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63271       };
63272     } catch (...) {
63273       {
63274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63275       };
63276     }
63277   }
63278
63279   jresult = (int)result;
63280   return jresult;
63281 }
63282
63283
63284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63285   void * jresult ;
63286   Dali::Toolkit::Control result;
63287
63288   {
63289     try {
63290       result = Dali::Toolkit::Internal::Control::New();
63291     } catch (std::out_of_range& e) {
63292       {
63293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (std::exception& e) {
63296       {
63297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63298       };
63299     } catch (Dali::DaliException e) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63302       };
63303     } catch (...) {
63304       {
63305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63306       };
63307     }
63308   }
63309
63310   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63311   return jresult;
63312 }
63313
63314
63315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63317   std::string *arg2 = 0 ;
63318
63319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63320   if (!jarg2) {
63321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63322     return ;
63323   }
63324   std::string arg2_str(jarg2);
63325   arg2 = &arg2_str;
63326   {
63327     try {
63328       (arg1)->SetStyleName((std::string const &)*arg2);
63329     } catch (std::out_of_range& e) {
63330       {
63331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63332       };
63333     } catch (std::exception& e) {
63334       {
63335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63336       };
63337     } catch (Dali::DaliException e) {
63338       {
63339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63340       };
63341     } catch (...) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63344       };
63345     }
63346   }
63347
63348
63349   //argout typemap for const std::string&
63350
63351 }
63352
63353
63354 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63355   char * jresult ;
63356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63357   std::string *result = 0 ;
63358
63359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63360   {
63361     try {
63362       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63363     } catch (std::out_of_range& e) {
63364       {
63365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63366       };
63367     } catch (std::exception& e) {
63368       {
63369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63370       };
63371     } catch (Dali::DaliException e) {
63372       {
63373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63374       };
63375     } catch (...) {
63376       {
63377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63378       };
63379     }
63380   }
63381
63382   jresult = SWIG_csharp_string_callback(result->c_str());
63383   return jresult;
63384 }
63385
63386
63387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63389   Dali::Vector4 *arg2 = 0 ;
63390
63391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63392   arg2 = (Dali::Vector4 *)jarg2;
63393   if (!arg2) {
63394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63395     return ;
63396   }
63397   {
63398     try {
63399       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63400     } catch (std::out_of_range& e) {
63401       {
63402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63403       };
63404     } catch (std::exception& e) {
63405       {
63406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63407       };
63408     } catch (Dali::DaliException e) {
63409       {
63410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63411       };
63412     } catch (...) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63415       };
63416     }
63417   }
63418
63419 }
63420
63421
63422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63423   void * jresult ;
63424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63425   Dali::Vector4 result;
63426
63427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63428   {
63429     try {
63430       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63431     } catch (std::out_of_range& e) {
63432       {
63433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63434       };
63435     } catch (std::exception& e) {
63436       {
63437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (Dali::DaliException e) {
63440       {
63441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63442       };
63443     } catch (...) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63446       };
63447     }
63448   }
63449
63450   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63451   return jresult;
63452 }
63453
63454
63455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63457   Dali::Image arg2 ;
63458   Dali::Image *argp2 ;
63459
63460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63461   argp2 = (Dali::Image *)jarg2;
63462   if (!argp2) {
63463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63464     return ;
63465   }
63466   arg2 = *argp2;
63467   {
63468     try {
63469       (arg1)->SetBackgroundImage(arg2);
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63485       };
63486     }
63487   }
63488
63489 }
63490
63491
63492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63493   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63494   Dali::Property::Map *arg2 = 0 ;
63495
63496   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63497   arg2 = (Dali::Property::Map *)jarg2;
63498   if (!arg2) {
63499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63500     return ;
63501   }
63502   {
63503     try {
63504       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63505     } catch (std::out_of_range& e) {
63506       {
63507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63508       };
63509     } catch (std::exception& e) {
63510       {
63511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63512       };
63513     } catch (Dali::DaliException e) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63520       };
63521     }
63522   }
63523
63524 }
63525
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63529
63530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63531   {
63532     try {
63533       (arg1)->ClearBackground();
63534     } catch (std::out_of_range& e) {
63535       {
63536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63537       };
63538     } catch (std::exception& e) {
63539       {
63540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (Dali::DaliException e) {
63543       {
63544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63545       };
63546     } catch (...) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63549       };
63550     }
63551   }
63552
63553 }
63554
63555
63556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63558   Dali::Gesture::Type arg2 ;
63559
63560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63561   arg2 = (Dali::Gesture::Type)jarg2;
63562   {
63563     try {
63564       (arg1)->EnableGestureDetection(arg2);
63565     } catch (std::out_of_range& e) {
63566       {
63567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63568       };
63569     } catch (std::exception& e) {
63570       {
63571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63572       };
63573     } catch (Dali::DaliException e) {
63574       {
63575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63576       };
63577     } catch (...) {
63578       {
63579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63580       };
63581     }
63582   }
63583
63584 }
63585
63586
63587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63589   Dali::Gesture::Type arg2 ;
63590
63591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63592   arg2 = (Dali::Gesture::Type)jarg2;
63593   {
63594     try {
63595       (arg1)->DisableGestureDetection(arg2);
63596     } catch (std::out_of_range& e) {
63597       {
63598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63599       };
63600     } catch (std::exception& e) {
63601       {
63602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63603       };
63604     } catch (Dali::DaliException e) {
63605       {
63606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63607       };
63608     } catch (...) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63611       };
63612     }
63613   }
63614
63615 }
63616
63617
63618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63619   void * jresult ;
63620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63621   Dali::PinchGestureDetector result;
63622
63623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63624   {
63625     try {
63626       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63627     } catch (std::out_of_range& e) {
63628       {
63629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (std::exception& e) {
63632       {
63633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63634       };
63635     } catch (Dali::DaliException e) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63638       };
63639     } catch (...) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63642       };
63643     }
63644   }
63645
63646   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63647   return jresult;
63648 }
63649
63650
63651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63652   void * jresult ;
63653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63654   Dali::PanGestureDetector result;
63655
63656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63657   {
63658     try {
63659       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63660     } catch (std::out_of_range& e) {
63661       {
63662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (std::exception& e) {
63665       {
63666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (Dali::DaliException e) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63671       };
63672     } catch (...) {
63673       {
63674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63675       };
63676     }
63677   }
63678
63679   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63680   return jresult;
63681 }
63682
63683
63684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63685   void * jresult ;
63686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63687   Dali::TapGestureDetector result;
63688
63689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63690   {
63691     try {
63692       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63693     } catch (std::out_of_range& e) {
63694       {
63695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (std::exception& e) {
63698       {
63699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63700       };
63701     } catch (Dali::DaliException e) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63704       };
63705     } catch (...) {
63706       {
63707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63708       };
63709     }
63710   }
63711
63712   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63713   return jresult;
63714 }
63715
63716
63717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63718   void * jresult ;
63719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63720   Dali::LongPressGestureDetector result;
63721
63722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63723   {
63724     try {
63725       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63726     } catch (std::out_of_range& e) {
63727       {
63728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63729       };
63730     } catch (std::exception& e) {
63731       {
63732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63733       };
63734     } catch (Dali::DaliException e) {
63735       {
63736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63737       };
63738     } catch (...) {
63739       {
63740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63741       };
63742     }
63743   }
63744
63745   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63746   return jresult;
63747 }
63748
63749
63750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63752   bool arg2 ;
63753
63754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63755   arg2 = jarg2 ? true : false;
63756   {
63757     try {
63758       (arg1)->SetKeyboardNavigationSupport(arg2);
63759     } catch (std::out_of_range& e) {
63760       {
63761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63762       };
63763     } catch (std::exception& e) {
63764       {
63765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63766       };
63767     } catch (Dali::DaliException e) {
63768       {
63769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63770       };
63771     } catch (...) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63774       };
63775     }
63776   }
63777
63778 }
63779
63780
63781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63782   unsigned int jresult ;
63783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63784   bool result;
63785
63786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63787   {
63788     try {
63789       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63790     } catch (std::out_of_range& e) {
63791       {
63792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63793       };
63794     } catch (std::exception& e) {
63795       {
63796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63797       };
63798     } catch (Dali::DaliException e) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63801       };
63802     } catch (...) {
63803       {
63804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63805       };
63806     }
63807   }
63808
63809   jresult = result;
63810   return jresult;
63811 }
63812
63813
63814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63816
63817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63818   {
63819     try {
63820       (arg1)->SetKeyInputFocus();
63821     } catch (std::out_of_range& e) {
63822       {
63823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63824       };
63825     } catch (std::exception& e) {
63826       {
63827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63828       };
63829     } catch (Dali::DaliException e) {
63830       {
63831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63832       };
63833     } catch (...) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63836       };
63837     }
63838   }
63839
63840 }
63841
63842
63843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63844   unsigned int jresult ;
63845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63846   bool result;
63847
63848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63849   {
63850     try {
63851       result = (bool)(arg1)->HasKeyInputFocus();
63852     } catch (std::out_of_range& e) {
63853       {
63854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63855       };
63856     } catch (std::exception& e) {
63857       {
63858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63859       };
63860     } catch (Dali::DaliException e) {
63861       {
63862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63863       };
63864     } catch (...) {
63865       {
63866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63867       };
63868     }
63869   }
63870
63871   jresult = result;
63872   return jresult;
63873 }
63874
63875
63876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63878
63879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63880   {
63881     try {
63882       (arg1)->ClearKeyInputFocus();
63883     } catch (std::out_of_range& e) {
63884       {
63885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63886       };
63887     } catch (std::exception& e) {
63888       {
63889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63890       };
63891     } catch (Dali::DaliException e) {
63892       {
63893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63894       };
63895     } catch (...) {
63896       {
63897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63898       };
63899     }
63900   }
63901
63902 }
63903
63904
63905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63907   bool arg2 ;
63908
63909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63910   arg2 = jarg2 ? true : false;
63911   {
63912     try {
63913       (arg1)->SetAsKeyboardFocusGroup(arg2);
63914     } catch (std::out_of_range& e) {
63915       {
63916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63917       };
63918     } catch (std::exception& e) {
63919       {
63920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63921       };
63922     } catch (Dali::DaliException e) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63925       };
63926     } catch (...) {
63927       {
63928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63929       };
63930     }
63931   }
63932
63933 }
63934
63935
63936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63937   unsigned int jresult ;
63938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63939   bool result;
63940
63941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63942   {
63943     try {
63944       result = (bool)(arg1)->IsKeyboardFocusGroup();
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (Dali::DaliException e) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63960       };
63961     }
63962   }
63963
63964   jresult = result;
63965   return jresult;
63966 }
63967
63968
63969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
63970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63971
63972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63973   {
63974     try {
63975       (arg1)->AccessibilityActivate();
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63983       };
63984     } catch (Dali::DaliException e) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63987       };
63988     } catch (...) {
63989       {
63990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63991       };
63992     }
63993   }
63994
63995 }
63996
63997
63998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
63999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64000
64001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64002   {
64003     try {
64004       (arg1)->KeyboardEnter();
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (Dali::DaliException e) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64016       };
64017     } catch (...) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64020       };
64021     }
64022   }
64023
64024 }
64025
64026
64027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64028   void * jresult ;
64029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64030   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64031
64032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64033   {
64034     try {
64035       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64036     } catch (std::out_of_range& e) {
64037       {
64038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64039       };
64040     } catch (std::exception& e) {
64041       {
64042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64043       };
64044     } catch (Dali::DaliException e) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64047       };
64048     } catch (...) {
64049       {
64050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64051       };
64052     }
64053   }
64054
64055   jresult = (void *)result;
64056   return jresult;
64057 }
64058
64059
64060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64061   void * jresult ;
64062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64063   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64064
64065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64066   {
64067     try {
64068       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64069     } catch (std::out_of_range& e) {
64070       {
64071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64072       };
64073     } catch (std::exception& e) {
64074       {
64075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64076       };
64077     } catch (Dali::DaliException e) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64080       };
64081     } catch (...) {
64082       {
64083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64084       };
64085     }
64086   }
64087
64088   jresult = (void *)result;
64089   return jresult;
64090 }
64091
64092
64093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64094   void * jresult ;
64095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64096   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64097
64098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64099   {
64100     try {
64101       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64102     } catch (std::out_of_range& e) {
64103       {
64104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64105       };
64106     } catch (std::exception& e) {
64107       {
64108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64109       };
64110     } catch (Dali::DaliException e) {
64111       {
64112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64113       };
64114     } catch (...) {
64115       {
64116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64117       };
64118     }
64119   }
64120
64121   jresult = (void *)result;
64122   return jresult;
64123 }
64124
64125
64126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64127   unsigned int jresult ;
64128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64129   Dali::KeyEvent *arg2 = 0 ;
64130   bool result;
64131
64132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64133   arg2 = (Dali::KeyEvent *)jarg2;
64134   if (!arg2) {
64135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64136     return 0;
64137   }
64138   {
64139     try {
64140       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64141     } catch (std::out_of_range& e) {
64142       {
64143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64144       };
64145     } catch (std::exception& e) {
64146       {
64147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64148       };
64149     } catch (Dali::DaliException e) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64152       };
64153     } catch (...) {
64154       {
64155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64156       };
64157     }
64158   }
64159
64160   jresult = result;
64161   return jresult;
64162 }
64163
64164
64165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64167   int arg2 ;
64168   SwigDirector_ViewImpl *darg = 0;
64169
64170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64171   arg2 = (int)jarg2;
64172   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64173   {
64174     try {
64175       (darg)->OnStageConnection(arg2);
64176     } catch (std::out_of_range& e) {
64177       {
64178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64179       };
64180     } catch (std::exception& e) {
64181       {
64182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64183       };
64184     } catch (Dali::DaliException e) {
64185       {
64186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64187       };
64188     } catch (...) {
64189       {
64190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64191       };
64192     }
64193   }
64194
64195 }
64196
64197
64198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64200   int arg2 ;
64201   SwigDirector_ViewImpl *darg = 0;
64202
64203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64204   arg2 = (int)jarg2;
64205   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64206   {
64207     try {
64208       (darg)->OnStageConnectionSwigPublic(arg2);
64209     } catch (std::out_of_range& e) {
64210       {
64211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64212       };
64213     } catch (std::exception& e) {
64214       {
64215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64216       };
64217     } catch (Dali::DaliException e) {
64218       {
64219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64220       };
64221     } catch (...) {
64222       {
64223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64224       };
64225     }
64226   }
64227
64228 }
64229
64230
64231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64233   SwigDirector_ViewImpl *darg = 0;
64234
64235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64236   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64237   {
64238     try {
64239       (darg)->OnStageDisconnection();
64240     } catch (std::out_of_range& e) {
64241       {
64242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64243       };
64244     } catch (std::exception& e) {
64245       {
64246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64247       };
64248     } catch (Dali::DaliException e) {
64249       {
64250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64251       };
64252     } catch (...) {
64253       {
64254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64255       };
64256     }
64257   }
64258
64259 }
64260
64261
64262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64264   SwigDirector_ViewImpl *darg = 0;
64265
64266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64268   {
64269     try {
64270       (darg)->OnStageDisconnectionSwigPublic();
64271     } catch (std::out_of_range& e) {
64272       {
64273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64274       };
64275     } catch (std::exception& e) {
64276       {
64277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64278       };
64279     } catch (Dali::DaliException e) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64282       };
64283     } catch (...) {
64284       {
64285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64286       };
64287     }
64288   }
64289
64290 }
64291
64292
64293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64295   Dali::Actor *arg2 = 0 ;
64296   SwigDirector_ViewImpl *darg = 0;
64297
64298   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64299   arg2 = (Dali::Actor *)jarg2;
64300   if (!arg2) {
64301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64302     return ;
64303   }
64304   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64305   {
64306     try {
64307       (darg)->OnChildAdd(*arg2);
64308     } catch (std::out_of_range& e) {
64309       {
64310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64311       };
64312     } catch (std::exception& e) {
64313       {
64314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64315       };
64316     } catch (Dali::DaliException e) {
64317       {
64318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64319       };
64320     } catch (...) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64323       };
64324     }
64325   }
64326
64327 }
64328
64329
64330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64332   Dali::Actor *arg2 = 0 ;
64333   SwigDirector_ViewImpl *darg = 0;
64334
64335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64336   arg2 = (Dali::Actor *)jarg2;
64337   if (!arg2) {
64338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64339     return ;
64340   }
64341   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64342   {
64343     try {
64344       (darg)->OnChildAddSwigPublic(*arg2);
64345     } catch (std::out_of_range& e) {
64346       {
64347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64348       };
64349     } catch (std::exception& e) {
64350       {
64351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64352       };
64353     } catch (Dali::DaliException e) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64356       };
64357     } catch (...) {
64358       {
64359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64360       };
64361     }
64362   }
64363
64364 }
64365
64366
64367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64369   Dali::Actor *arg2 = 0 ;
64370   SwigDirector_ViewImpl *darg = 0;
64371
64372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64373   arg2 = (Dali::Actor *)jarg2;
64374   if (!arg2) {
64375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64376     return ;
64377   }
64378   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64379   {
64380     try {
64381       (darg)->OnChildRemove(*arg2);
64382     } catch (std::out_of_range& e) {
64383       {
64384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64385       };
64386     } catch (std::exception& e) {
64387       {
64388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64389       };
64390     } catch (Dali::DaliException e) {
64391       {
64392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64393       };
64394     } catch (...) {
64395       {
64396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64397       };
64398     }
64399   }
64400
64401 }
64402
64403
64404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64406   Dali::Actor *arg2 = 0 ;
64407   SwigDirector_ViewImpl *darg = 0;
64408
64409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64410   arg2 = (Dali::Actor *)jarg2;
64411   if (!arg2) {
64412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64413     return ;
64414   }
64415   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64416   {
64417     try {
64418       (darg)->OnChildRemoveSwigPublic(*arg2);
64419     } catch (std::out_of_range& e) {
64420       {
64421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64422       };
64423     } catch (std::exception& e) {
64424       {
64425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64426       };
64427     } catch (Dali::DaliException e) {
64428       {
64429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64430       };
64431     } catch (...) {
64432       {
64433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64434       };
64435     }
64436   }
64437
64438 }
64439
64440
64441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64443   Dali::Property::Index arg2 ;
64444   Dali::Property::Value arg3 ;
64445   Dali::Property::Value *argp3 ;
64446   SwigDirector_ViewImpl *darg = 0;
64447
64448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64449   arg2 = (Dali::Property::Index)jarg2;
64450   argp3 = (Dali::Property::Value *)jarg3;
64451   if (!argp3) {
64452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64453     return ;
64454   }
64455   arg3 = *argp3;
64456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64457   {
64458     try {
64459       (darg)->OnPropertySet(arg2,arg3);
64460     } catch (std::out_of_range& e) {
64461       {
64462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64463       };
64464     } catch (std::exception& e) {
64465       {
64466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64467       };
64468     } catch (Dali::DaliException e) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64471       };
64472     } catch (...) {
64473       {
64474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64475       };
64476     }
64477   }
64478
64479 }
64480
64481
64482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64484   Dali::Property::Index arg2 ;
64485   Dali::Property::Value arg3 ;
64486   Dali::Property::Value *argp3 ;
64487   SwigDirector_ViewImpl *darg = 0;
64488
64489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64490   arg2 = (Dali::Property::Index)jarg2;
64491   argp3 = (Dali::Property::Value *)jarg3;
64492   if (!argp3) {
64493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64494     return ;
64495   }
64496   arg3 = *argp3;
64497   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64498   {
64499     try {
64500       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64501     } catch (std::out_of_range& e) {
64502       {
64503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64504       };
64505     } catch (std::exception& e) {
64506       {
64507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64508       };
64509     } catch (Dali::DaliException e) {
64510       {
64511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64512       };
64513     } catch (...) {
64514       {
64515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64516       };
64517     }
64518   }
64519
64520 }
64521
64522
64523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64525   Dali::Vector3 *arg2 = 0 ;
64526   SwigDirector_ViewImpl *darg = 0;
64527
64528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64529   arg2 = (Dali::Vector3 *)jarg2;
64530   if (!arg2) {
64531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64532     return ;
64533   }
64534   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64535   {
64536     try {
64537       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64538     } catch (std::out_of_range& e) {
64539       {
64540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64541       };
64542     } catch (std::exception& e) {
64543       {
64544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64545       };
64546     } catch (Dali::DaliException e) {
64547       {
64548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64549       };
64550     } catch (...) {
64551       {
64552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64553       };
64554     }
64555   }
64556
64557 }
64558
64559
64560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64562   Dali::Vector3 *arg2 = 0 ;
64563   SwigDirector_ViewImpl *darg = 0;
64564
64565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64566   arg2 = (Dali::Vector3 *)jarg2;
64567   if (!arg2) {
64568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64569     return ;
64570   }
64571   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64572   {
64573     try {
64574       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64575     } catch (std::out_of_range& e) {
64576       {
64577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64578       };
64579     } catch (std::exception& e) {
64580       {
64581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64582       };
64583     } catch (Dali::DaliException e) {
64584       {
64585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64586       };
64587     } catch (...) {
64588       {
64589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64590       };
64591     }
64592   }
64593
64594 }
64595
64596
64597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64599   Dali::Animation *arg2 = 0 ;
64600   Dali::Vector3 *arg3 = 0 ;
64601   SwigDirector_ViewImpl *darg = 0;
64602
64603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64604   arg2 = (Dali::Animation *)jarg2;
64605   if (!arg2) {
64606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64607     return ;
64608   }
64609   arg3 = (Dali::Vector3 *)jarg3;
64610   if (!arg3) {
64611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64612     return ;
64613   }
64614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64615   {
64616     try {
64617       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64618     } catch (std::out_of_range& e) {
64619       {
64620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64621       };
64622     } catch (std::exception& e) {
64623       {
64624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64625       };
64626     } catch (Dali::DaliException e) {
64627       {
64628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64629       };
64630     } catch (...) {
64631       {
64632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64633       };
64634     }
64635   }
64636
64637 }
64638
64639
64640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64642   Dali::Animation *arg2 = 0 ;
64643   Dali::Vector3 *arg3 = 0 ;
64644   SwigDirector_ViewImpl *darg = 0;
64645
64646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64647   arg2 = (Dali::Animation *)jarg2;
64648   if (!arg2) {
64649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64650     return ;
64651   }
64652   arg3 = (Dali::Vector3 *)jarg3;
64653   if (!arg3) {
64654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64655     return ;
64656   }
64657   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64658   {
64659     try {
64660       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64661     } catch (std::out_of_range& e) {
64662       {
64663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64664       };
64665     } catch (std::exception& e) {
64666       {
64667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64668       };
64669     } catch (Dali::DaliException e) {
64670       {
64671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64672       };
64673     } catch (...) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64676       };
64677     }
64678   }
64679
64680 }
64681
64682
64683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64684   unsigned int jresult ;
64685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64686   Dali::TouchEvent *arg2 = 0 ;
64687   SwigDirector_ViewImpl *darg = 0;
64688   bool result;
64689
64690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64691   arg2 = (Dali::TouchEvent *)jarg2;
64692   if (!arg2) {
64693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64694     return 0;
64695   }
64696   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64697   {
64698     try {
64699       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64700     } catch (std::out_of_range& e) {
64701       {
64702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64703       };
64704     } catch (std::exception& e) {
64705       {
64706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64707       };
64708     } catch (Dali::DaliException e) {
64709       {
64710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64711       };
64712     } catch (...) {
64713       {
64714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64715       };
64716     }
64717   }
64718
64719   jresult = result;
64720   return jresult;
64721 }
64722
64723
64724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64725   unsigned int jresult ;
64726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64727   Dali::TouchEvent *arg2 = 0 ;
64728   SwigDirector_ViewImpl *darg = 0;
64729   bool result;
64730
64731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64732   arg2 = (Dali::TouchEvent *)jarg2;
64733   if (!arg2) {
64734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64735     return 0;
64736   }
64737   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64738   {
64739     try {
64740       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64741     } catch (std::out_of_range& e) {
64742       {
64743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64744       };
64745     } catch (std::exception& e) {
64746       {
64747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64748       };
64749     } catch (Dali::DaliException e) {
64750       {
64751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64752       };
64753     } catch (...) {
64754       {
64755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64756       };
64757     }
64758   }
64759
64760   jresult = result;
64761   return jresult;
64762 }
64763
64764
64765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64766   unsigned int jresult ;
64767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64768   Dali::HoverEvent *arg2 = 0 ;
64769   SwigDirector_ViewImpl *darg = 0;
64770   bool result;
64771
64772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64773   arg2 = (Dali::HoverEvent *)jarg2;
64774   if (!arg2) {
64775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64776     return 0;
64777   }
64778   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64779   {
64780     try {
64781       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64782     } catch (std::out_of_range& e) {
64783       {
64784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64785       };
64786     } catch (std::exception& e) {
64787       {
64788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64789       };
64790     } catch (Dali::DaliException e) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64793       };
64794     } catch (...) {
64795       {
64796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64797       };
64798     }
64799   }
64800
64801   jresult = result;
64802   return jresult;
64803 }
64804
64805
64806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64807   unsigned int jresult ;
64808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64809   Dali::HoverEvent *arg2 = 0 ;
64810   SwigDirector_ViewImpl *darg = 0;
64811   bool result;
64812
64813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64814   arg2 = (Dali::HoverEvent *)jarg2;
64815   if (!arg2) {
64816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64817     return 0;
64818   }
64819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64820   {
64821     try {
64822       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64823     } catch (std::out_of_range& e) {
64824       {
64825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64826       };
64827     } catch (std::exception& e) {
64828       {
64829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64830       };
64831     } catch (Dali::DaliException e) {
64832       {
64833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64834       };
64835     } catch (...) {
64836       {
64837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64838       };
64839     }
64840   }
64841
64842   jresult = result;
64843   return jresult;
64844 }
64845
64846
64847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64848   unsigned int jresult ;
64849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64850   Dali::KeyEvent *arg2 = 0 ;
64851   SwigDirector_ViewImpl *darg = 0;
64852   bool result;
64853
64854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64855   arg2 = (Dali::KeyEvent *)jarg2;
64856   if (!arg2) {
64857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64858     return 0;
64859   }
64860   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64861   {
64862     try {
64863       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64864     } catch (std::out_of_range& e) {
64865       {
64866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64867       };
64868     } catch (std::exception& e) {
64869       {
64870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64871       };
64872     } catch (Dali::DaliException e) {
64873       {
64874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64875       };
64876     } catch (...) {
64877       {
64878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64879       };
64880     }
64881   }
64882
64883   jresult = result;
64884   return jresult;
64885 }
64886
64887
64888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64889   unsigned int jresult ;
64890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64891   Dali::KeyEvent *arg2 = 0 ;
64892   SwigDirector_ViewImpl *darg = 0;
64893   bool result;
64894
64895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64896   arg2 = (Dali::KeyEvent *)jarg2;
64897   if (!arg2) {
64898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64899     return 0;
64900   }
64901   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64902   {
64903     try {
64904       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64905     } catch (std::out_of_range& e) {
64906       {
64907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64908       };
64909     } catch (std::exception& e) {
64910       {
64911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64912       };
64913     } catch (Dali::DaliException e) {
64914       {
64915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64916       };
64917     } catch (...) {
64918       {
64919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64920       };
64921     }
64922   }
64923
64924   jresult = result;
64925   return jresult;
64926 }
64927
64928
64929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64930   unsigned int jresult ;
64931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64932   Dali::WheelEvent *arg2 = 0 ;
64933   SwigDirector_ViewImpl *darg = 0;
64934   bool result;
64935
64936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64937   arg2 = (Dali::WheelEvent *)jarg2;
64938   if (!arg2) {
64939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64940     return 0;
64941   }
64942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64943   {
64944     try {
64945       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64946     } catch (std::out_of_range& e) {
64947       {
64948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64949       };
64950     } catch (std::exception& e) {
64951       {
64952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64953       };
64954     } catch (Dali::DaliException e) {
64955       {
64956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64957       };
64958     } catch (...) {
64959       {
64960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64961       };
64962     }
64963   }
64964
64965   jresult = result;
64966   return jresult;
64967 }
64968
64969
64970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64971   unsigned int jresult ;
64972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64973   Dali::WheelEvent *arg2 = 0 ;
64974   SwigDirector_ViewImpl *darg = 0;
64975   bool result;
64976
64977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64978   arg2 = (Dali::WheelEvent *)jarg2;
64979   if (!arg2) {
64980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64981     return 0;
64982   }
64983   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64984   {
64985     try {
64986       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64987     } catch (std::out_of_range& e) {
64988       {
64989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (std::exception& e) {
64992       {
64993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (Dali::DaliException e) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64998       };
64999     } catch (...) {
65000       {
65001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65002       };
65003     }
65004   }
65005
65006   jresult = result;
65007   return jresult;
65008 }
65009
65010
65011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65013   Dali::Vector2 *arg2 = 0 ;
65014   Dali::RelayoutContainer *arg3 = 0 ;
65015   SwigDirector_ViewImpl *darg = 0;
65016
65017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65018   arg2 = (Dali::Vector2 *)jarg2;
65019   if (!arg2) {
65020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65021     return ;
65022   }
65023   arg3 = (Dali::RelayoutContainer *)jarg3;
65024   if (!arg3) {
65025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65026     return ;
65027   }
65028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65029   {
65030     try {
65031       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65032     } catch (std::out_of_range& e) {
65033       {
65034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65035       };
65036     } catch (std::exception& e) {
65037       {
65038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65039       };
65040     } catch (Dali::DaliException e) {
65041       {
65042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65043       };
65044     } catch (...) {
65045       {
65046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65047       };
65048     }
65049   }
65050
65051 }
65052
65053
65054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65056   Dali::Vector2 *arg2 = 0 ;
65057   Dali::RelayoutContainer *arg3 = 0 ;
65058   SwigDirector_ViewImpl *darg = 0;
65059
65060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65061   arg2 = (Dali::Vector2 *)jarg2;
65062   if (!arg2) {
65063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65064     return ;
65065   }
65066   arg3 = (Dali::RelayoutContainer *)jarg3;
65067   if (!arg3) {
65068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65069     return ;
65070   }
65071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65072   {
65073     try {
65074       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65075     } catch (std::out_of_range& e) {
65076       {
65077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65078       };
65079     } catch (std::exception& e) {
65080       {
65081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65082       };
65083     } catch (Dali::DaliException e) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65086       };
65087     } catch (...) {
65088       {
65089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65090       };
65091     }
65092   }
65093
65094 }
65095
65096
65097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65099   Dali::ResizePolicy::Type arg2 ;
65100   Dali::Dimension::Type arg3 ;
65101   SwigDirector_ViewImpl *darg = 0;
65102
65103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65104   arg2 = (Dali::ResizePolicy::Type)jarg2;
65105   arg3 = (Dali::Dimension::Type)jarg3;
65106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65107   {
65108     try {
65109       (darg)->OnSetResizePolicy(arg2,arg3);
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65117       };
65118     } catch (Dali::DaliException e) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65121       };
65122     } catch (...) {
65123       {
65124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65125       };
65126     }
65127   }
65128
65129 }
65130
65131
65132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65134   Dali::ResizePolicy::Type arg2 ;
65135   Dali::Dimension::Type arg3 ;
65136   SwigDirector_ViewImpl *darg = 0;
65137
65138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65139   arg2 = (Dali::ResizePolicy::Type)jarg2;
65140   arg3 = (Dali::Dimension::Type)jarg3;
65141   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65142   {
65143     try {
65144       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65145     } catch (std::out_of_range& e) {
65146       {
65147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65148       };
65149     } catch (std::exception& e) {
65150       {
65151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65152       };
65153     } catch (Dali::DaliException e) {
65154       {
65155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65156       };
65157     } catch (...) {
65158       {
65159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65160       };
65161     }
65162   }
65163
65164 }
65165
65166
65167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65168   void * jresult ;
65169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65170   SwigDirector_ViewImpl *darg = 0;
65171   Dali::Vector3 result;
65172
65173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65174   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65175   {
65176     try {
65177       result = (darg)->GetNaturalSize();
65178     } catch (std::out_of_range& e) {
65179       {
65180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (std::exception& e) {
65183       {
65184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (Dali::DaliException e) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196
65197   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65198   return jresult;
65199 }
65200
65201
65202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65203   void * jresult ;
65204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65205   SwigDirector_ViewImpl *darg = 0;
65206   Dali::Vector3 result;
65207
65208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65209   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65210   {
65211     try {
65212       result = (darg)->GetNaturalSizeSwigPublic();
65213     } catch (std::out_of_range& e) {
65214       {
65215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65216       };
65217     } catch (std::exception& e) {
65218       {
65219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65220       };
65221     } catch (Dali::DaliException e) {
65222       {
65223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65224       };
65225     } catch (...) {
65226       {
65227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65228       };
65229     }
65230   }
65231
65232   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65233   return jresult;
65234 }
65235
65236
65237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65238   float jresult ;
65239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65240   Dali::Actor *arg2 = 0 ;
65241   Dali::Dimension::Type arg3 ;
65242   SwigDirector_ViewImpl *darg = 0;
65243   float result;
65244
65245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65246   arg2 = (Dali::Actor *)jarg2;
65247   if (!arg2) {
65248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65249     return 0;
65250   }
65251   arg3 = (Dali::Dimension::Type)jarg3;
65252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65253   {
65254     try {
65255       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65256     } catch (std::out_of_range& e) {
65257       {
65258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65259       };
65260     } catch (std::exception& e) {
65261       {
65262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65263       };
65264     } catch (Dali::DaliException e) {
65265       {
65266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65267       };
65268     } catch (...) {
65269       {
65270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65271       };
65272     }
65273   }
65274
65275   jresult = result;
65276   return jresult;
65277 }
65278
65279
65280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65281   float jresult ;
65282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65283   Dali::Actor *arg2 = 0 ;
65284   Dali::Dimension::Type arg3 ;
65285   SwigDirector_ViewImpl *darg = 0;
65286   float result;
65287
65288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65289   arg2 = (Dali::Actor *)jarg2;
65290   if (!arg2) {
65291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65292     return 0;
65293   }
65294   arg3 = (Dali::Dimension::Type)jarg3;
65295   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65296   {
65297     try {
65298       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65299     } catch (std::out_of_range& e) {
65300       {
65301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (std::exception& e) {
65304       {
65305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65306       };
65307     } catch (Dali::DaliException e) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65310       };
65311     } catch (...) {
65312       {
65313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65314       };
65315     }
65316   }
65317
65318   jresult = result;
65319   return jresult;
65320 }
65321
65322
65323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65324   float jresult ;
65325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65326   float arg2 ;
65327   SwigDirector_ViewImpl *darg = 0;
65328   float result;
65329
65330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65331   arg2 = (float)jarg2;
65332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65333   {
65334     try {
65335       result = (float)(darg)->GetHeightForWidth(arg2);
65336     } catch (std::out_of_range& e) {
65337       {
65338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65339       };
65340     } catch (std::exception& e) {
65341       {
65342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65343       };
65344     } catch (Dali::DaliException e) {
65345       {
65346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65347       };
65348     } catch (...) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65351       };
65352     }
65353   }
65354
65355   jresult = result;
65356   return jresult;
65357 }
65358
65359
65360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65361   float jresult ;
65362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65363   float arg2 ;
65364   SwigDirector_ViewImpl *darg = 0;
65365   float result;
65366
65367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65368   arg2 = (float)jarg2;
65369   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65370   {
65371     try {
65372       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65373     } catch (std::out_of_range& e) {
65374       {
65375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65376       };
65377     } catch (std::exception& e) {
65378       {
65379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65380       };
65381     } catch (Dali::DaliException e) {
65382       {
65383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65384       };
65385     } catch (...) {
65386       {
65387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65388       };
65389     }
65390   }
65391
65392   jresult = result;
65393   return jresult;
65394 }
65395
65396
65397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65398   float jresult ;
65399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65400   float arg2 ;
65401   SwigDirector_ViewImpl *darg = 0;
65402   float result;
65403
65404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65405   arg2 = (float)jarg2;
65406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65407   {
65408     try {
65409       result = (float)(darg)->GetWidthForHeight(arg2);
65410     } catch (std::out_of_range& e) {
65411       {
65412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65413       };
65414     } catch (std::exception& e) {
65415       {
65416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65417       };
65418     } catch (Dali::DaliException e) {
65419       {
65420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65421       };
65422     } catch (...) {
65423       {
65424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65425       };
65426     }
65427   }
65428
65429   jresult = result;
65430   return jresult;
65431 }
65432
65433
65434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65435   float jresult ;
65436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65437   float arg2 ;
65438   SwigDirector_ViewImpl *darg = 0;
65439   float result;
65440
65441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65442   arg2 = (float)jarg2;
65443   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65444   {
65445     try {
65446       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65447     } catch (std::out_of_range& e) {
65448       {
65449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65450       };
65451     } catch (std::exception& e) {
65452       {
65453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65454       };
65455     } catch (Dali::DaliException e) {
65456       {
65457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65458       };
65459     } catch (...) {
65460       {
65461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65462       };
65463     }
65464   }
65465
65466   jresult = result;
65467   return jresult;
65468 }
65469
65470
65471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65472   unsigned int jresult ;
65473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65474   Dali::Dimension::Type arg2 ;
65475   SwigDirector_ViewImpl *darg = 0;
65476   bool result;
65477
65478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65479   arg2 = (Dali::Dimension::Type)jarg2;
65480   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65481   {
65482     try {
65483       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65484     } catch (std::out_of_range& e) {
65485       {
65486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65487       };
65488     } catch (std::exception& e) {
65489       {
65490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65491       };
65492     } catch (Dali::DaliException e) {
65493       {
65494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65495       };
65496     } catch (...) {
65497       {
65498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65499       };
65500     }
65501   }
65502
65503   jresult = result;
65504   return jresult;
65505 }
65506
65507
65508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65509   unsigned int jresult ;
65510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65511   Dali::Dimension::Type arg2 ;
65512   SwigDirector_ViewImpl *darg = 0;
65513   bool result;
65514
65515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65516   arg2 = (Dali::Dimension::Type)jarg2;
65517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65518   {
65519     try {
65520       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65521     } catch (std::out_of_range& e) {
65522       {
65523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65524       };
65525     } catch (std::exception& e) {
65526       {
65527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65528       };
65529     } catch (Dali::DaliException e) {
65530       {
65531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65532       };
65533     } catch (...) {
65534       {
65535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65536       };
65537     }
65538   }
65539
65540   jresult = result;
65541   return jresult;
65542 }
65543
65544
65545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65546   unsigned int jresult ;
65547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65548   SwigDirector_ViewImpl *darg = 0;
65549   bool result;
65550
65551   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65552   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65553   {
65554     try {
65555       result = (bool)(darg)->RelayoutDependentOnChildren();
65556     } catch (std::out_of_range& e) {
65557       {
65558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65559       };
65560     } catch (std::exception& e) {
65561       {
65562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65563       };
65564     } catch (Dali::DaliException e) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65567       };
65568     } catch (...) {
65569       {
65570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65571       };
65572     }
65573   }
65574
65575   jresult = result;
65576   return jresult;
65577 }
65578
65579
65580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65581   unsigned int jresult ;
65582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65583   SwigDirector_ViewImpl *darg = 0;
65584   bool result;
65585
65586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65587   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65588   {
65589     try {
65590       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65591     } catch (std::out_of_range& e) {
65592       {
65593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65594       };
65595     } catch (std::exception& e) {
65596       {
65597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65598       };
65599     } catch (Dali::DaliException e) {
65600       {
65601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65602       };
65603     } catch (...) {
65604       {
65605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65606       };
65607     }
65608   }
65609
65610   jresult = result;
65611   return jresult;
65612 }
65613
65614
65615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65617   Dali::Dimension::Type arg2 ;
65618   SwigDirector_ViewImpl *darg = 0;
65619
65620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65621   arg2 = (Dali::Dimension::Type)jarg2;
65622   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65623   {
65624     try {
65625       (darg)->OnCalculateRelayoutSize(arg2);
65626     } catch (std::out_of_range& e) {
65627       {
65628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65629       };
65630     } catch (std::exception& e) {
65631       {
65632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65633       };
65634     } catch (Dali::DaliException e) {
65635       {
65636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65637       };
65638     } catch (...) {
65639       {
65640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65641       };
65642     }
65643   }
65644
65645 }
65646
65647
65648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65650   Dali::Dimension::Type arg2 ;
65651   SwigDirector_ViewImpl *darg = 0;
65652
65653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65654   arg2 = (Dali::Dimension::Type)jarg2;
65655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65656   {
65657     try {
65658       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65666       };
65667     } catch (Dali::DaliException e) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65670       };
65671     } catch (...) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65674       };
65675     }
65676   }
65677
65678 }
65679
65680
65681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65683   float arg2 ;
65684   Dali::Dimension::Type arg3 ;
65685   SwigDirector_ViewImpl *darg = 0;
65686
65687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65688   arg2 = (float)jarg2;
65689   arg3 = (Dali::Dimension::Type)jarg3;
65690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65691   {
65692     try {
65693       (darg)->OnLayoutNegotiated(arg2,arg3);
65694     } catch (std::out_of_range& e) {
65695       {
65696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65697       };
65698     } catch (std::exception& e) {
65699       {
65700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65701       };
65702     } catch (Dali::DaliException e) {
65703       {
65704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65705       };
65706     } catch (...) {
65707       {
65708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65709       };
65710     }
65711   }
65712
65713 }
65714
65715
65716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65718   float arg2 ;
65719   Dali::Dimension::Type arg3 ;
65720   SwigDirector_ViewImpl *darg = 0;
65721
65722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65723   arg2 = (float)jarg2;
65724   arg3 = (Dali::Dimension::Type)jarg3;
65725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65726   {
65727     try {
65728       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65729     } catch (std::out_of_range& e) {
65730       {
65731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65732       };
65733     } catch (std::exception& e) {
65734       {
65735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65736       };
65737     } catch (Dali::DaliException e) {
65738       {
65739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65740       };
65741     } catch (...) {
65742       {
65743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65744       };
65745     }
65746   }
65747
65748 }
65749
65750
65751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65753
65754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65755   {
65756     try {
65757       (arg1)->OnInitialize();
65758     } catch (std::out_of_range& e) {
65759       {
65760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65761       };
65762     } catch (std::exception& e) {
65763       {
65764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65765       };
65766     } catch (Dali::DaliException e) {
65767       {
65768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65769       };
65770     } catch (...) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65773       };
65774     }
65775   }
65776
65777 }
65778
65779
65780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65782
65783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65784   {
65785     try {
65786       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65787     } catch (std::out_of_range& e) {
65788       {
65789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65790       };
65791     } catch (std::exception& e) {
65792       {
65793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65794       };
65795     } catch (Dali::DaliException e) {
65796       {
65797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65798       };
65799     } catch (...) {
65800       {
65801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65802       };
65803     }
65804   }
65805
65806 }
65807
65808
65809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65811   Dali::Actor *arg2 = 0 ;
65812
65813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65814   arg2 = (Dali::Actor *)jarg2;
65815   if (!arg2) {
65816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65817     return ;
65818   }
65819   {
65820     try {
65821       (arg1)->OnControlChildAdd(*arg2);
65822     } catch (std::out_of_range& e) {
65823       {
65824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65825       };
65826     } catch (std::exception& e) {
65827       {
65828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65829       };
65830     } catch (Dali::DaliException e) {
65831       {
65832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65833       };
65834     } catch (...) {
65835       {
65836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65837       };
65838     }
65839   }
65840
65841 }
65842
65843
65844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65846   Dali::Actor *arg2 = 0 ;
65847
65848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65849   arg2 = (Dali::Actor *)jarg2;
65850   if (!arg2) {
65851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65852     return ;
65853   }
65854   {
65855     try {
65856       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65857     } catch (std::out_of_range& e) {
65858       {
65859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65860       };
65861     } catch (std::exception& e) {
65862       {
65863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65864       };
65865     } catch (Dali::DaliException e) {
65866       {
65867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65868       };
65869     } catch (...) {
65870       {
65871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65872       };
65873     }
65874   }
65875
65876 }
65877
65878
65879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65881   Dali::Actor *arg2 = 0 ;
65882
65883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65884   arg2 = (Dali::Actor *)jarg2;
65885   if (!arg2) {
65886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65887     return ;
65888   }
65889   {
65890     try {
65891       (arg1)->OnControlChildRemove(*arg2);
65892     } catch (std::out_of_range& e) {
65893       {
65894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65895       };
65896     } catch (std::exception& e) {
65897       {
65898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65899       };
65900     } catch (Dali::DaliException e) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65903       };
65904     } catch (...) {
65905       {
65906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65907       };
65908     }
65909   }
65910
65911 }
65912
65913
65914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65916   Dali::Actor *arg2 = 0 ;
65917
65918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65919   arg2 = (Dali::Actor *)jarg2;
65920   if (!arg2) {
65921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65922     return ;
65923   }
65924   {
65925     try {
65926       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65927     } catch (std::out_of_range& e) {
65928       {
65929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65930       };
65931     } catch (std::exception& e) {
65932       {
65933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65934       };
65935     } catch (Dali::DaliException e) {
65936       {
65937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65938       };
65939     } catch (...) {
65940       {
65941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65942       };
65943     }
65944   }
65945
65946 }
65947
65948
65949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65951   Dali::Toolkit::StyleManager arg2 ;
65952   Dali::StyleChange::Type arg3 ;
65953   Dali::Toolkit::StyleManager *argp2 ;
65954
65955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65956   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65957   if (!argp2) {
65958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65959     return ;
65960   }
65961   arg2 = *argp2;
65962   arg3 = (Dali::StyleChange::Type)jarg3;
65963   {
65964     try {
65965       (arg1)->OnStyleChange(arg2,arg3);
65966     } catch (std::out_of_range& e) {
65967       {
65968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65969       };
65970     } catch (std::exception& e) {
65971       {
65972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65973       };
65974     } catch (Dali::DaliException e) {
65975       {
65976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65977       };
65978     } catch (...) {
65979       {
65980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65981       };
65982     }
65983   }
65984
65985 }
65986
65987
65988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65990   Dali::Toolkit::StyleManager arg2 ;
65991   Dali::StyleChange::Type arg3 ;
65992   Dali::Toolkit::StyleManager *argp2 ;
65993
65994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65995   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65996   if (!argp2) {
65997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65998     return ;
65999   }
66000   arg2 = *argp2;
66001   arg3 = (Dali::StyleChange::Type)jarg3;
66002   {
66003     try {
66004       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66005     } catch (std::out_of_range& e) {
66006       {
66007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66008       };
66009     } catch (std::exception& e) {
66010       {
66011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66012       };
66013     } catch (Dali::DaliException e) {
66014       {
66015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66016       };
66017     } catch (...) {
66018       {
66019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66020       };
66021     }
66022   }
66023
66024 }
66025
66026
66027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66028   unsigned int jresult ;
66029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66030   bool result;
66031
66032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66033   {
66034     try {
66035       result = (bool)(arg1)->OnAccessibilityActivated();
66036     } catch (std::out_of_range& e) {
66037       {
66038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66039       };
66040     } catch (std::exception& e) {
66041       {
66042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66043       };
66044     } catch (Dali::DaliException e) {
66045       {
66046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66047       };
66048     } catch (...) {
66049       {
66050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66051       };
66052     }
66053   }
66054
66055   jresult = result;
66056   return jresult;
66057 }
66058
66059
66060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66061   unsigned int jresult ;
66062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66063   bool result;
66064
66065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66066   {
66067     try {
66068       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66069     } catch (std::out_of_range& e) {
66070       {
66071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66072       };
66073     } catch (std::exception& e) {
66074       {
66075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (Dali::DaliException e) {
66078       {
66079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66080       };
66081     } catch (...) {
66082       {
66083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66084       };
66085     }
66086   }
66087
66088   jresult = result;
66089   return jresult;
66090 }
66091
66092
66093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66094   unsigned int jresult ;
66095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66096   Dali::PanGesture arg2 ;
66097   Dali::PanGesture *argp2 ;
66098   bool result;
66099
66100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66101   argp2 = (Dali::PanGesture *)jarg2;
66102   if (!argp2) {
66103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66104     return 0;
66105   }
66106   arg2 = *argp2;
66107   {
66108     try {
66109       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66110     } catch (std::out_of_range& e) {
66111       {
66112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66113       };
66114     } catch (std::exception& e) {
66115       {
66116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66117       };
66118     } catch (Dali::DaliException e) {
66119       {
66120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66121       };
66122     } catch (...) {
66123       {
66124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66125       };
66126     }
66127   }
66128
66129   jresult = result;
66130   return jresult;
66131 }
66132
66133
66134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66135   unsigned int jresult ;
66136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66137   Dali::PanGesture arg2 ;
66138   Dali::PanGesture *argp2 ;
66139   bool result;
66140
66141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66142   argp2 = (Dali::PanGesture *)jarg2;
66143   if (!argp2) {
66144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66145     return 0;
66146   }
66147   arg2 = *argp2;
66148   {
66149     try {
66150       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66151     } catch (std::out_of_range& e) {
66152       {
66153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66154       };
66155     } catch (std::exception& e) {
66156       {
66157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66158       };
66159     } catch (Dali::DaliException e) {
66160       {
66161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66166       };
66167     }
66168   }
66169
66170   jresult = result;
66171   return jresult;
66172 }
66173
66174
66175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66176   unsigned int jresult ;
66177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66178   Dali::TouchEvent *arg2 = 0 ;
66179   bool result;
66180
66181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66182   arg2 = (Dali::TouchEvent *)jarg2;
66183   if (!arg2) {
66184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66185     return 0;
66186   }
66187   {
66188     try {
66189       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66190     } catch (std::out_of_range& e) {
66191       {
66192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66193       };
66194     } catch (std::exception& e) {
66195       {
66196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66197       };
66198     } catch (Dali::DaliException e) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66201       };
66202     } catch (...) {
66203       {
66204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66205       };
66206     }
66207   }
66208
66209   jresult = result;
66210   return jresult;
66211 }
66212
66213
66214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66215   unsigned int jresult ;
66216   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66217   Dali::TouchEvent *arg2 = 0 ;
66218   bool result;
66219
66220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66221   arg2 = (Dali::TouchEvent *)jarg2;
66222   if (!arg2) {
66223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66224     return 0;
66225   }
66226   {
66227     try {
66228       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66229     } catch (std::out_of_range& e) {
66230       {
66231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66232       };
66233     } catch (std::exception& e) {
66234       {
66235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66236       };
66237     } catch (Dali::DaliException e) {
66238       {
66239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66240       };
66241     } catch (...) {
66242       {
66243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66244       };
66245     }
66246   }
66247
66248   jresult = result;
66249   return jresult;
66250 }
66251
66252
66253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66254   unsigned int jresult ;
66255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66256   bool arg2 ;
66257   bool result;
66258
66259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66260   arg2 = jarg2 ? true : false;
66261   {
66262     try {
66263       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66264     } catch (std::out_of_range& e) {
66265       {
66266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66267       };
66268     } catch (std::exception& e) {
66269       {
66270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66271       };
66272     } catch (Dali::DaliException e) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66275       };
66276     } catch (...) {
66277       {
66278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66279       };
66280     }
66281   }
66282
66283   jresult = result;
66284   return jresult;
66285 }
66286
66287
66288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66289   unsigned int jresult ;
66290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66291   bool arg2 ;
66292   bool result;
66293
66294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66295   arg2 = jarg2 ? true : false;
66296   {
66297     try {
66298       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66299     } catch (std::out_of_range& e) {
66300       {
66301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66302       };
66303     } catch (std::exception& e) {
66304       {
66305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66306       };
66307     } catch (Dali::DaliException e) {
66308       {
66309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66310       };
66311     } catch (...) {
66312       {
66313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66314       };
66315     }
66316   }
66317
66318   jresult = result;
66319   return jresult;
66320 }
66321
66322
66323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66324   unsigned int jresult ;
66325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66326   bool result;
66327
66328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66329   {
66330     try {
66331       result = (bool)(arg1)->OnAccessibilityZoom();
66332     } catch (std::out_of_range& e) {
66333       {
66334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66335       };
66336     } catch (std::exception& e) {
66337       {
66338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66339       };
66340     } catch (Dali::DaliException e) {
66341       {
66342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66343       };
66344     } catch (...) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66347       };
66348     }
66349   }
66350
66351   jresult = result;
66352   return jresult;
66353 }
66354
66355
66356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66357   unsigned int jresult ;
66358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66359   bool result;
66360
66361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66362   {
66363     try {
66364       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66365     } catch (std::out_of_range& e) {
66366       {
66367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66368       };
66369     } catch (std::exception& e) {
66370       {
66371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66372       };
66373     } catch (Dali::DaliException e) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66376       };
66377     } catch (...) {
66378       {
66379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66380       };
66381     }
66382   }
66383
66384   jresult = result;
66385   return jresult;
66386 }
66387
66388
66389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66391
66392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66393   {
66394     try {
66395       (arg1)->OnKeyInputFocusGained();
66396     } catch (std::out_of_range& e) {
66397       {
66398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66399       };
66400     } catch (std::exception& e) {
66401       {
66402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66403       };
66404     } catch (Dali::DaliException e) {
66405       {
66406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66407       };
66408     } catch (...) {
66409       {
66410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66411       };
66412     }
66413   }
66414
66415 }
66416
66417
66418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66420
66421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66422   {
66423     try {
66424       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66425     } catch (std::out_of_range& e) {
66426       {
66427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66428       };
66429     } catch (std::exception& e) {
66430       {
66431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66432       };
66433     } catch (Dali::DaliException e) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66436       };
66437     } catch (...) {
66438       {
66439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66440       };
66441     }
66442   }
66443
66444 }
66445
66446
66447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66449
66450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66451   {
66452     try {
66453       (arg1)->OnKeyInputFocusLost();
66454     } catch (std::out_of_range& e) {
66455       {
66456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66457       };
66458     } catch (std::exception& e) {
66459       {
66460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66461       };
66462     } catch (Dali::DaliException e) {
66463       {
66464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66465       };
66466     } catch (...) {
66467       {
66468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66469       };
66470     }
66471   }
66472
66473 }
66474
66475
66476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66478
66479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66480   {
66481     try {
66482       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66483     } catch (std::out_of_range& e) {
66484       {
66485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66486       };
66487     } catch (std::exception& e) {
66488       {
66489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66490       };
66491     } catch (Dali::DaliException e) {
66492       {
66493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66494       };
66495     } catch (...) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66498       };
66499     }
66500   }
66501
66502 }
66503
66504
66505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66506   void * jresult ;
66507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66508   Dali::Actor arg2 ;
66509   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66510   bool arg4 ;
66511   Dali::Actor *argp2 ;
66512   Dali::Actor result;
66513
66514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66515   argp2 = (Dali::Actor *)jarg2;
66516   if (!argp2) {
66517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66518     return 0;
66519   }
66520   arg2 = *argp2;
66521   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66522   arg4 = jarg4 ? true : false;
66523   {
66524     try {
66525       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66526     } catch (std::out_of_range& e) {
66527       {
66528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66529       };
66530     } catch (std::exception& e) {
66531       {
66532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66533       };
66534     } catch (Dali::DaliException e) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66537       };
66538     } catch (...) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66541       };
66542     }
66543   }
66544
66545   jresult = new Dali::Actor((const Dali::Actor &)result);
66546   return jresult;
66547 }
66548
66549
66550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66551   void * jresult ;
66552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66553   Dali::Actor arg2 ;
66554   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66555   bool arg4 ;
66556   Dali::Actor *argp2 ;
66557   Dali::Actor result;
66558
66559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66560   argp2 = (Dali::Actor *)jarg2;
66561   if (!argp2) {
66562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66563     return 0;
66564   }
66565   arg2 = *argp2;
66566   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66567   arg4 = jarg4 ? true : false;
66568   {
66569     try {
66570       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66571     } catch (std::out_of_range& e) {
66572       {
66573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (std::exception& e) {
66576       {
66577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66578       };
66579     } catch (Dali::DaliException e) {
66580       {
66581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66582       };
66583     } catch (...) {
66584       {
66585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66586       };
66587     }
66588   }
66589
66590   jresult = new Dali::Actor((const Dali::Actor &)result);
66591   return jresult;
66592 }
66593
66594
66595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66597   Dali::Actor arg2 ;
66598   Dali::Actor *argp2 ;
66599
66600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66601   argp2 = (Dali::Actor *)jarg2;
66602   if (!argp2) {
66603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66604     return ;
66605   }
66606   arg2 = *argp2;
66607   {
66608     try {
66609       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66610     } catch (std::out_of_range& e) {
66611       {
66612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66613       };
66614     } catch (std::exception& e) {
66615       {
66616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66617       };
66618     } catch (Dali::DaliException e) {
66619       {
66620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66621       };
66622     } catch (...) {
66623       {
66624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66625       };
66626     }
66627   }
66628
66629 }
66630
66631
66632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66634   Dali::Actor arg2 ;
66635   Dali::Actor *argp2 ;
66636
66637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66638   argp2 = (Dali::Actor *)jarg2;
66639   if (!argp2) {
66640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66641     return ;
66642   }
66643   arg2 = *argp2;
66644   {
66645     try {
66646       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66647     } catch (std::out_of_range& e) {
66648       {
66649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66650       };
66651     } catch (std::exception& e) {
66652       {
66653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66654       };
66655     } catch (Dali::DaliException e) {
66656       {
66657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66658       };
66659     } catch (...) {
66660       {
66661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66662       };
66663     }
66664   }
66665
66666 }
66667
66668
66669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66670   unsigned int jresult ;
66671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66672   bool result;
66673
66674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66675   {
66676     try {
66677       result = (bool)(arg1)->OnKeyboardEnter();
66678     } catch (std::out_of_range& e) {
66679       {
66680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66681       };
66682     } catch (std::exception& e) {
66683       {
66684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66685       };
66686     } catch (Dali::DaliException e) {
66687       {
66688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66689       };
66690     } catch (...) {
66691       {
66692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66693       };
66694     }
66695   }
66696
66697   jresult = result;
66698   return jresult;
66699 }
66700
66701
66702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66703   unsigned int jresult ;
66704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66705   bool result;
66706
66707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66708   {
66709     try {
66710       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66711     } catch (std::out_of_range& e) {
66712       {
66713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66714       };
66715     } catch (std::exception& e) {
66716       {
66717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66718       };
66719     } catch (Dali::DaliException e) {
66720       {
66721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66722       };
66723     } catch (...) {
66724       {
66725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66726       };
66727     }
66728   }
66729
66730   jresult = result;
66731   return jresult;
66732 }
66733
66734
66735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66737   Dali::PinchGesture *arg2 = 0 ;
66738
66739   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66740   arg2 = (Dali::PinchGesture *)jarg2;
66741   if (!arg2) {
66742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66743     return ;
66744   }
66745   {
66746     try {
66747       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66748     } catch (std::out_of_range& e) {
66749       {
66750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66751       };
66752     } catch (std::exception& e) {
66753       {
66754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66755       };
66756     } catch (Dali::DaliException e) {
66757       {
66758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66759       };
66760     } catch (...) {
66761       {
66762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66763       };
66764     }
66765   }
66766
66767 }
66768
66769
66770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66772   Dali::PinchGesture *arg2 = 0 ;
66773
66774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66775   arg2 = (Dali::PinchGesture *)jarg2;
66776   if (!arg2) {
66777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66778     return ;
66779   }
66780   {
66781     try {
66782       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66783     } catch (std::out_of_range& e) {
66784       {
66785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66786       };
66787     } catch (std::exception& e) {
66788       {
66789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66790       };
66791     } catch (Dali::DaliException e) {
66792       {
66793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66794       };
66795     } catch (...) {
66796       {
66797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66798       };
66799     }
66800   }
66801
66802 }
66803
66804
66805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66807   Dali::PanGesture *arg2 = 0 ;
66808
66809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66810   arg2 = (Dali::PanGesture *)jarg2;
66811   if (!arg2) {
66812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66813     return ;
66814   }
66815   {
66816     try {
66817       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66818     } catch (std::out_of_range& e) {
66819       {
66820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66821       };
66822     } catch (std::exception& e) {
66823       {
66824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66825       };
66826     } catch (Dali::DaliException e) {
66827       {
66828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66833       };
66834     }
66835   }
66836
66837 }
66838
66839
66840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66842   Dali::PanGesture *arg2 = 0 ;
66843
66844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66845   arg2 = (Dali::PanGesture *)jarg2;
66846   if (!arg2) {
66847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66848     return ;
66849   }
66850   {
66851     try {
66852       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66853     } catch (std::out_of_range& e) {
66854       {
66855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66856       };
66857     } catch (std::exception& e) {
66858       {
66859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66860       };
66861     } catch (Dali::DaliException e) {
66862       {
66863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66864       };
66865     } catch (...) {
66866       {
66867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66868       };
66869     }
66870   }
66871
66872 }
66873
66874
66875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66877   Dali::TapGesture *arg2 = 0 ;
66878
66879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66880   arg2 = (Dali::TapGesture *)jarg2;
66881   if (!arg2) {
66882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66883     return ;
66884   }
66885   {
66886     try {
66887       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66888     } catch (std::out_of_range& e) {
66889       {
66890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66891       };
66892     } catch (std::exception& e) {
66893       {
66894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66895       };
66896     } catch (Dali::DaliException e) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66899       };
66900     } catch (...) {
66901       {
66902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66903       };
66904     }
66905   }
66906
66907 }
66908
66909
66910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66912   Dali::TapGesture *arg2 = 0 ;
66913
66914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66915   arg2 = (Dali::TapGesture *)jarg2;
66916   if (!arg2) {
66917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66918     return ;
66919   }
66920   {
66921     try {
66922       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66923     } catch (std::out_of_range& e) {
66924       {
66925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66926       };
66927     } catch (std::exception& e) {
66928       {
66929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66930       };
66931     } catch (Dali::DaliException e) {
66932       {
66933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66934       };
66935     } catch (...) {
66936       {
66937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66938       };
66939     }
66940   }
66941
66942 }
66943
66944
66945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66947   Dali::LongPressGesture *arg2 = 0 ;
66948
66949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66950   arg2 = (Dali::LongPressGesture *)jarg2;
66951   if (!arg2) {
66952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66953     return ;
66954   }
66955   {
66956     try {
66957       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66958     } catch (std::out_of_range& e) {
66959       {
66960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66961       };
66962     } catch (std::exception& e) {
66963       {
66964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66965       };
66966     } catch (Dali::DaliException e) {
66967       {
66968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66969       };
66970     } catch (...) {
66971       {
66972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66973       };
66974     }
66975   }
66976
66977 }
66978
66979
66980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66982   Dali::LongPressGesture *arg2 = 0 ;
66983
66984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66985   arg2 = (Dali::LongPressGesture *)jarg2;
66986   if (!arg2) {
66987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66988     return ;
66989   }
66990   {
66991     try {
66992       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66993     } catch (std::out_of_range& e) {
66994       {
66995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66996       };
66997     } catch (std::exception& e) {
66998       {
66999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67000       };
67001     } catch (Dali::DaliException e) {
67002       {
67003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67004       };
67005     } catch (...) {
67006       {
67007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67008       };
67009     }
67010   }
67011
67012 }
67013
67014
67015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67017   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67018   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67019
67020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67021   arg2 = (Dali::SlotObserver *)jarg2;
67022   arg3 = (Dali::CallbackBase *)jarg3;
67023   {
67024     try {
67025       (arg1)->SignalConnected(arg2,arg3);
67026     } catch (std::out_of_range& e) {
67027       {
67028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67029       };
67030     } catch (std::exception& e) {
67031       {
67032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67033       };
67034     } catch (Dali::DaliException e) {
67035       {
67036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67037       };
67038     } catch (...) {
67039       {
67040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67041       };
67042     }
67043   }
67044
67045 }
67046
67047
67048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67050   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67051   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67052
67053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67054   arg2 = (Dali::SlotObserver *)jarg2;
67055   arg3 = (Dali::CallbackBase *)jarg3;
67056   {
67057     try {
67058       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67059     } catch (std::out_of_range& e) {
67060       {
67061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67062       };
67063     } catch (std::exception& e) {
67064       {
67065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (Dali::DaliException e) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67070       };
67071     } catch (...) {
67072       {
67073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67074       };
67075     }
67076   }
67077
67078 }
67079
67080
67081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67083   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67084   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67085
67086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67087   arg2 = (Dali::SlotObserver *)jarg2;
67088   arg3 = (Dali::CallbackBase *)jarg3;
67089   {
67090     try {
67091       (arg1)->SignalDisconnected(arg2,arg3);
67092     } catch (std::out_of_range& e) {
67093       {
67094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67095       };
67096     } catch (std::exception& e) {
67097       {
67098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67099       };
67100     } catch (Dali::DaliException e) {
67101       {
67102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67103       };
67104     } catch (...) {
67105       {
67106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67107       };
67108     }
67109   }
67110
67111 }
67112
67113
67114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67116   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67117   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67118
67119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67120   arg2 = (Dali::SlotObserver *)jarg2;
67121   arg3 = (Dali::CallbackBase *)jarg3;
67122   {
67123     try {
67124       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67125     } catch (std::out_of_range& e) {
67126       {
67127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67128       };
67129     } catch (std::exception& e) {
67130       {
67131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67132       };
67133     } catch (Dali::DaliException e) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67136       };
67137     } catch (...) {
67138       {
67139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67140       };
67141     }
67142   }
67143
67144 }
67145
67146
67147 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) {
67148   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67149   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67150   if (director) {
67151     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);
67152   }
67153 }
67154
67155
67156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67157   void * jresult ;
67158   Dali::Toolkit::Control *arg1 = 0 ;
67159   Dali::Toolkit::Internal::Control *result = 0 ;
67160
67161   arg1 = (Dali::Toolkit::Control *)jarg1;
67162   if (!arg1) {
67163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67164     return 0;
67165   }
67166   {
67167     try {
67168       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67169     } catch (std::out_of_range& e) {
67170       {
67171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67172       };
67173     } catch (std::exception& e) {
67174       {
67175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67176       };
67177     } catch (Dali::DaliException e) {
67178       {
67179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67180       };
67181     } catch (...) {
67182       {
67183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67184       };
67185     }
67186   }
67187
67188   jresult = (void *)result;
67189   return jresult;
67190 }
67191
67192
67193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67194   int jresult ;
67195   int result;
67196
67197   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67198   jresult = (int)result;
67199   return jresult;
67200 }
67201
67202
67203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67204   int jresult ;
67205   int result;
67206
67207   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67208   jresult = (int)result;
67209   return jresult;
67210 }
67211
67212
67213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67214   int jresult ;
67215   int result;
67216
67217   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67218   jresult = (int)result;
67219   return jresult;
67220 }
67221
67222
67223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67224   int jresult ;
67225   int result;
67226
67227   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67228   jresult = (int)result;
67229   return jresult;
67230 }
67231
67232
67233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67234   int jresult ;
67235   int result;
67236
67237   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67238   jresult = (int)result;
67239   return jresult;
67240 }
67241
67242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67243   int jresult ;
67244   int result;
67245
67246   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67247   jresult = (int)result;
67248   return jresult;
67249 }
67250
67251
67252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67253   int jresult ;
67254   int result;
67255
67256   result = (int)Dali::Toolkit::Control::Property::PADDING;
67257   jresult = (int)result;
67258   return jresult;
67259 }
67260
67261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67262   void * jresult ;
67263   Dali::Toolkit::Control::Property *result = 0 ;
67264
67265   {
67266     try {
67267       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67268     } catch (std::out_of_range& e) {
67269       {
67270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (std::exception& e) {
67273       {
67274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (Dali::DaliException e) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67279       };
67280     } catch (...) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67283       };
67284     }
67285   }
67286
67287   jresult = (void *)result;
67288   return jresult;
67289 }
67290
67291
67292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67293   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67294
67295   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67296   {
67297     try {
67298       delete arg1;
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317
67318 }
67319
67320
67321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67322   void * jresult ;
67323   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67324
67325   {
67326     try {
67327       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67328     } catch (std::out_of_range& e) {
67329       {
67330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67331       };
67332     } catch (std::exception& e) {
67333       {
67334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67335       };
67336     } catch (Dali::DaliException e) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67339       };
67340     } catch (...) {
67341       {
67342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67343       };
67344     }
67345   }
67346
67347   jresult = (void *)result;
67348   return jresult;
67349 }
67350
67351
67352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67353   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67354
67355   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67356   {
67357     try {
67358       delete arg1;
67359     } catch (std::out_of_range& e) {
67360       {
67361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67362       };
67363     } catch (std::exception& e) {
67364       {
67365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67366       };
67367     } catch (Dali::DaliException e) {
67368       {
67369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67370       };
67371     } catch (...) {
67372       {
67373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67374       };
67375     }
67376   }
67377
67378 }
67379
67380
67381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67382   void * jresult ;
67383   Dali::Toolkit::Control result;
67384
67385   {
67386     try {
67387       result = Dali::Toolkit::Control::New();
67388     } catch (std::out_of_range& e) {
67389       {
67390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67391       };
67392     } catch (std::exception& e) {
67393       {
67394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (Dali::DaliException e) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67403       };
67404     }
67405   }
67406
67407   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67408   return jresult;
67409 }
67410
67411
67412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67413   void * jresult ;
67414   Dali::Toolkit::Control *result = 0 ;
67415
67416   {
67417     try {
67418       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67419     } catch (std::out_of_range& e) {
67420       {
67421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67422       };
67423     } catch (std::exception& e) {
67424       {
67425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (Dali::DaliException e) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67430       };
67431     } catch (...) {
67432       {
67433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67434       };
67435     }
67436   }
67437
67438   jresult = (void *)result;
67439   return jresult;
67440 }
67441
67442
67443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67444   void * jresult ;
67445   Dali::Toolkit::Control *arg1 = 0 ;
67446   Dali::Toolkit::Control *result = 0 ;
67447
67448   arg1 = (Dali::Toolkit::Control *)jarg1;
67449   if (!arg1) {
67450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67451     return 0;
67452   }
67453   {
67454     try {
67455       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67456     } catch (std::out_of_range& e) {
67457       {
67458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67459       };
67460     } catch (std::exception& e) {
67461       {
67462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67463       };
67464     } catch (Dali::DaliException e) {
67465       {
67466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67467       };
67468     } catch (...) {
67469       {
67470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67471       };
67472     }
67473   }
67474
67475   jresult = (void *)result;
67476   return jresult;
67477 }
67478
67479
67480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67481   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67482
67483   arg1 = (Dali::Toolkit::Control *)jarg1;
67484   {
67485     try {
67486       delete arg1;
67487     } catch (std::out_of_range& e) {
67488       {
67489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67490       };
67491     } catch (std::exception& e) {
67492       {
67493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67494       };
67495     } catch (Dali::DaliException e) {
67496       {
67497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67498       };
67499     } catch (...) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67502       };
67503     }
67504   }
67505
67506 }
67507
67508
67509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67510   void * jresult ;
67511   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67512   Dali::Toolkit::Control *arg2 = 0 ;
67513   Dali::Toolkit::Control *result = 0 ;
67514
67515   arg1 = (Dali::Toolkit::Control *)jarg1;
67516   arg2 = (Dali::Toolkit::Control *)jarg2;
67517   if (!arg2) {
67518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67519     return 0;
67520   }
67521   {
67522     try {
67523       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67524     } catch (std::out_of_range& e) {
67525       {
67526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67527       };
67528     } catch (std::exception& e) {
67529       {
67530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67531       };
67532     } catch (Dali::DaliException e) {
67533       {
67534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67535       };
67536     } catch (...) {
67537       {
67538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67539       };
67540     }
67541   }
67542
67543   jresult = (void *)result;
67544   return jresult;
67545 }
67546
67547
67548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67549   void * jresult ;
67550   Dali::BaseHandle arg1 ;
67551   Dali::BaseHandle *argp1 ;
67552   Dali::Toolkit::Control result;
67553
67554   argp1 = (Dali::BaseHandle *)jarg1;
67555   if (!argp1) {
67556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67557     return 0;
67558   }
67559   arg1 = *argp1;
67560   {
67561     try {
67562       result = Dali::Toolkit::Control::DownCast(arg1);
67563     } catch (std::out_of_range& e) {
67564       {
67565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67566       };
67567     } catch (std::exception& e) {
67568       {
67569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67570       };
67571     } catch (Dali::DaliException e) {
67572       {
67573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67574       };
67575     } catch (...) {
67576       {
67577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67578       };
67579     }
67580   }
67581
67582   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67583   return jresult;
67584 }
67585
67586
67587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67588   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67589
67590   arg1 = (Dali::Toolkit::Control *)jarg1;
67591   {
67592     try {
67593       (arg1)->SetKeyInputFocus();
67594     } catch (std::out_of_range& e) {
67595       {
67596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67597       };
67598     } catch (std::exception& e) {
67599       {
67600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67601       };
67602     } catch (Dali::DaliException e) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67605       };
67606     } catch (...) {
67607       {
67608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67609       };
67610     }
67611   }
67612
67613 }
67614
67615
67616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67617   unsigned int jresult ;
67618   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67619   bool result;
67620
67621   arg1 = (Dali::Toolkit::Control *)jarg1;
67622   {
67623     try {
67624       result = (bool)(arg1)->HasKeyInputFocus();
67625     } catch (std::out_of_range& e) {
67626       {
67627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67628       };
67629     } catch (std::exception& e) {
67630       {
67631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67632       };
67633     } catch (Dali::DaliException e) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67636       };
67637     } catch (...) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67640       };
67641     }
67642   }
67643
67644   jresult = result;
67645   return jresult;
67646 }
67647
67648
67649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67650   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67651
67652   arg1 = (Dali::Toolkit::Control *)jarg1;
67653   {
67654     try {
67655       (arg1)->ClearKeyInputFocus();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67663       };
67664     } catch (Dali::DaliException e) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67667       };
67668     } catch (...) {
67669       {
67670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67671       };
67672     }
67673   }
67674
67675 }
67676
67677
67678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67679   void * jresult ;
67680   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67681   Dali::PinchGestureDetector result;
67682
67683   arg1 = (Dali::Toolkit::Control *)jarg1;
67684   {
67685     try {
67686       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67687     } catch (std::out_of_range& e) {
67688       {
67689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67690       };
67691     } catch (std::exception& e) {
67692       {
67693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67694       };
67695     } catch (Dali::DaliException e) {
67696       {
67697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67698       };
67699     } catch (...) {
67700       {
67701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67702       };
67703     }
67704   }
67705
67706   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67707   return jresult;
67708 }
67709
67710
67711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67712   void * jresult ;
67713   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67714   Dali::PanGestureDetector result;
67715
67716   arg1 = (Dali::Toolkit::Control *)jarg1;
67717   {
67718     try {
67719       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67720     } catch (std::out_of_range& e) {
67721       {
67722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67723       };
67724     } catch (std::exception& e) {
67725       {
67726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67727       };
67728     } catch (Dali::DaliException e) {
67729       {
67730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67731       };
67732     } catch (...) {
67733       {
67734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67735       };
67736     }
67737   }
67738
67739   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67740   return jresult;
67741 }
67742
67743
67744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67745   void * jresult ;
67746   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67747   Dali::TapGestureDetector result;
67748
67749   arg1 = (Dali::Toolkit::Control *)jarg1;
67750   {
67751     try {
67752       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67753     } catch (std::out_of_range& e) {
67754       {
67755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67756       };
67757     } catch (std::exception& e) {
67758       {
67759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67760       };
67761     } catch (Dali::DaliException e) {
67762       {
67763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67764       };
67765     } catch (...) {
67766       {
67767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67768       };
67769     }
67770   }
67771
67772   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67773   return jresult;
67774 }
67775
67776
67777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67778   void * jresult ;
67779   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67780   Dali::LongPressGestureDetector result;
67781
67782   arg1 = (Dali::Toolkit::Control *)jarg1;
67783   {
67784     try {
67785       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67786     } catch (std::out_of_range& e) {
67787       {
67788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (std::exception& e) {
67791       {
67792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67793       };
67794     } catch (Dali::DaliException e) {
67795       {
67796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67797       };
67798     } catch (...) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67801       };
67802     }
67803   }
67804
67805   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67806   return jresult;
67807 }
67808
67809
67810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67811   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67812   std::string *arg2 = 0 ;
67813
67814   arg1 = (Dali::Toolkit::Control *)jarg1;
67815   if (!jarg2) {
67816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67817     return ;
67818   }
67819   std::string arg2_str(jarg2);
67820   arg2 = &arg2_str;
67821   {
67822     try {
67823       (arg1)->SetStyleName((std::string const &)*arg2);
67824     } catch (std::out_of_range& e) {
67825       {
67826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67827       };
67828     } catch (std::exception& e) {
67829       {
67830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67831       };
67832     } catch (Dali::DaliException e) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67835       };
67836     } catch (...) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67839       };
67840     }
67841   }
67842
67843
67844   //argout typemap for const std::string&
67845
67846 }
67847
67848
67849 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67850   char * jresult ;
67851   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67852   std::string *result = 0 ;
67853
67854   arg1 = (Dali::Toolkit::Control *)jarg1;
67855   {
67856     try {
67857       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67858     } catch (std::out_of_range& e) {
67859       {
67860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67861       };
67862     } catch (std::exception& e) {
67863       {
67864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67865       };
67866     } catch (Dali::DaliException e) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67869       };
67870     } catch (...) {
67871       {
67872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67873       };
67874     }
67875   }
67876
67877   jresult = SWIG_csharp_string_callback(result->c_str());
67878   return jresult;
67879 }
67880
67881
67882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67883   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67884   Dali::Vector4 *arg2 = 0 ;
67885
67886   arg1 = (Dali::Toolkit::Control *)jarg1;
67887   arg2 = (Dali::Vector4 *)jarg2;
67888   if (!arg2) {
67889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67890     return ;
67891   }
67892   {
67893     try {
67894       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67895     } catch (std::out_of_range& e) {
67896       {
67897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67898       };
67899     } catch (std::exception& e) {
67900       {
67901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67902       };
67903     } catch (Dali::DaliException e) {
67904       {
67905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67906       };
67907     } catch (...) {
67908       {
67909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67910       };
67911     }
67912   }
67913
67914 }
67915
67916
67917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67918   void * jresult ;
67919   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67920   Dali::Vector4 result;
67921
67922   arg1 = (Dali::Toolkit::Control *)jarg1;
67923   {
67924     try {
67925       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67926     } catch (std::out_of_range& e) {
67927       {
67928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (std::exception& e) {
67931       {
67932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (Dali::DaliException e) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67937       };
67938     } catch (...) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67941       };
67942     }
67943   }
67944
67945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67946   return jresult;
67947 }
67948
67949
67950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67951   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67952   Dali::Image arg2 ;
67953   Dali::Image *argp2 ;
67954
67955   arg1 = (Dali::Toolkit::Control *)jarg1;
67956   argp2 = (Dali::Image *)jarg2;
67957   if (!argp2) {
67958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67959     return ;
67960   }
67961   arg2 = *argp2;
67962   {
67963     try {
67964       (arg1)->SetBackgroundImage(arg2);
67965     } catch (std::out_of_range& e) {
67966       {
67967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67968       };
67969     } catch (std::exception& e) {
67970       {
67971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67972       };
67973     } catch (Dali::DaliException e) {
67974       {
67975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67976       };
67977     } catch (...) {
67978       {
67979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67980       };
67981     }
67982   }
67983
67984 }
67985
67986
67987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67988   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67989
67990   arg1 = (Dali::Toolkit::Control *)jarg1;
67991   {
67992     try {
67993       (arg1)->ClearBackground();
67994     } catch (std::out_of_range& e) {
67995       {
67996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67997       };
67998     } catch (std::exception& e) {
67999       {
68000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68001       };
68002     } catch (Dali::DaliException e) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68005       };
68006     } catch (...) {
68007       {
68008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68009       };
68010     }
68011   }
68012
68013 }
68014
68015
68016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68017   void * jresult ;
68018   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68019   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68020
68021   arg1 = (Dali::Toolkit::Control *)jarg1;
68022   {
68023     try {
68024       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68025     } catch (std::out_of_range& e) {
68026       {
68027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68028       };
68029     } catch (std::exception& e) {
68030       {
68031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68032       };
68033     } catch (Dali::DaliException e) {
68034       {
68035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68036       };
68037     } catch (...) {
68038       {
68039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68040       };
68041     }
68042   }
68043
68044   jresult = (void *)result;
68045   return jresult;
68046 }
68047
68048
68049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68050   void * jresult ;
68051   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68052   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68053
68054   arg1 = (Dali::Toolkit::Control *)jarg1;
68055   {
68056     try {
68057       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68065       };
68066     } catch (Dali::DaliException e) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68069       };
68070     } catch (...) {
68071       {
68072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68073       };
68074     }
68075   }
68076
68077   jresult = (void *)result;
68078   return jresult;
68079 }
68080
68081
68082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68083   void * jresult ;
68084   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68085   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68086
68087   arg1 = (Dali::Toolkit::Control *)jarg1;
68088   {
68089     try {
68090       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68091     } catch (std::out_of_range& e) {
68092       {
68093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68094       };
68095     } catch (std::exception& e) {
68096       {
68097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68098       };
68099     } catch (Dali::DaliException e) {
68100       {
68101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68102       };
68103     } catch (...) {
68104       {
68105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68106       };
68107     }
68108   }
68109
68110   jresult = (void *)result;
68111   return jresult;
68112 }
68113
68114
68115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68116   void * jresult ;
68117   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68118   Dali::Toolkit::Control *result = 0 ;
68119
68120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68121   if (!arg1) {
68122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68123     return 0;
68124   }
68125   {
68126     try {
68127       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68128     } catch (std::out_of_range& e) {
68129       {
68130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (std::exception& e) {
68133       {
68134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68135       };
68136     } catch (Dali::DaliException e) {
68137       {
68138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68139       };
68140     } catch (...) {
68141       {
68142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68143       };
68144     }
68145   }
68146
68147   jresult = (void *)result;
68148   return jresult;
68149 }
68150
68151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68152 {
68153   int jresult;
68154   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68155   arg1 = (Dali::Toolkit::Control *)jarg1;
68156
68157   if (!arg1) {
68158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68159     return 0;
68160   }
68161
68162   Dali::Property::Index arg2 = 0 ;
68163   arg2 = (Dali::Property::Index)jarg2;
68164
68165   Toolkit::Visual::ResourceStatus result;
68166   {
68167     try {
68168       result = arg1->GetVisualResourceStatus(arg2);
68169     } catch (std::out_of_range& e) {
68170       {
68171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68172       };
68173     } catch (std::exception& e) {
68174       {
68175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68176       };
68177     } catch (...) {
68178       {
68179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68180       };
68181     }
68182   }
68183   jresult = (int)(result);
68184   return jresult;
68185 }
68186
68187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68188 {
68189   void * jresult;
68190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68191   arg1 = (Dali::Toolkit::Control *)jarg1;
68192
68193   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68194
68195   Dali::Toolkit::TransitionData *arg2 = 0 ;
68196   Dali::Animation result;
68197
68198   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68199   if (!arg2) {
68200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68201     return 0;
68202   }
68203   {
68204     try {
68205       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68206     } catch (std::out_of_range& e) {
68207       {
68208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68209       };
68210     } catch (std::exception& e) {
68211       {
68212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68213       };
68214     } catch (Dali::DaliException e) {
68215       {
68216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68217       };
68218     } catch (...) {
68219       {
68220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68221       };
68222     }
68223   }
68224
68225   jresult = new Dali::Animation((const Dali::Animation &)result);
68226   return jresult;
68227 }
68228
68229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68230 {
68231   Dali::Toolkit::Control arg1;
68232   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68233
68234   if (!argp1) {
68235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68236   }
68237   arg1 = *argp1;
68238
68239   Dali::Property::Index arg2 = 0 ;
68240   arg2 = (Dali::Property::Index)jarg2;
68241
68242   Dali::Property::Index arg3 = 0 ;
68243   arg3 = (Dali::Property::Index)jarg3;
68244
68245   Dali::Property::Value arg4;
68246   arg4 = (Dali::Property::Value *)jarg4;
68247
68248   {
68249     try {
68250       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68251     } catch (std::out_of_range& e) {
68252       {
68253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68254       };
68255     } catch (std::exception& e) {
68256       {
68257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68258       };
68259     } catch (...) {
68260       {
68261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68262       };
68263     }
68264   }
68265
68266
68267 }
68268
68269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68270   void * jresult ;
68271   Dali::Toolkit::Control *arg1 = 0 ;
68272   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68273
68274   arg1 = (Dali::Toolkit::Control *)jarg1;
68275   if (!arg1) {
68276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68277     return 0;
68278   }
68279   {
68280     try {
68281       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68282     } catch (std::out_of_range& e) {
68283       {
68284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (std::exception& e) {
68287       {
68288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68289       };
68290     } catch (Dali::DaliException e) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68293       };
68294     } catch (...) {
68295       {
68296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68297       };
68298     }
68299   }
68300
68301   jresult = (void *)result;
68302   return jresult;
68303 }
68304
68305
68306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68307   unsigned int jresult ;
68308   Dali::Toolkit::Control *arg1 = 0 ;
68309   bool result;
68310
68311   arg1 = (Dali::Toolkit::Control *)jarg1;
68312   if (!arg1) {
68313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68314     return 0;
68315   }
68316   {
68317     try {
68318       result = (bool)arg1->IsResourceReady();
68319     } catch (std::out_of_range& e) {
68320       {
68321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68322       };
68323     } catch (std::exception& e) {
68324       {
68325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68326       };
68327     } catch (Dali::DaliException e) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68330       };
68331     } catch (...) {
68332       {
68333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68334       };
68335     }
68336   }
68337
68338   jresult = result;
68339   return jresult;
68340 }
68341
68342
68343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68344   void * jresult ;
68345   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68346
68347   {
68348     try {
68349       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68350     } catch (std::out_of_range& e) {
68351       {
68352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68353       };
68354     } catch (std::exception& e) {
68355       {
68356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68357       };
68358     } catch (Dali::DaliException e) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68361       };
68362     } catch (...) {
68363       {
68364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68365       };
68366     }
68367   }
68368
68369   jresult = (void *)result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68375   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68376
68377   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68378   {
68379     try {
68380       delete arg1;
68381     } catch (std::out_of_range& e) {
68382       {
68383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68384       };
68385     } catch (std::exception& e) {
68386       {
68387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68388       };
68389     } catch (Dali::DaliException e) {
68390       {
68391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68392       };
68393     } catch (...) {
68394       {
68395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68396       };
68397     }
68398   }
68399
68400 }
68401
68402
68403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68404   void * jresult ;
68405   Dali::Toolkit::KeyInputFocusManager result;
68406
68407   {
68408     try {
68409       result = Dali::Toolkit::KeyInputFocusManager::Get();
68410     } catch (std::out_of_range& e) {
68411       {
68412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68413       };
68414     } catch (std::exception& e) {
68415       {
68416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68417       };
68418     } catch (Dali::DaliException e) {
68419       {
68420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68421       };
68422     } catch (...) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68425       };
68426     }
68427   }
68428
68429   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68430   return jresult;
68431 }
68432
68433
68434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68435   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68436   Dali::Toolkit::Control arg2 ;
68437   Dali::Toolkit::Control *argp2 ;
68438
68439   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68440   argp2 = (Dali::Toolkit::Control *)jarg2;
68441   if (!argp2) {
68442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68443     return ;
68444   }
68445   arg2 = *argp2;
68446   {
68447     try {
68448       (arg1)->SetFocus(arg2);
68449     } catch (std::out_of_range& e) {
68450       {
68451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68452       };
68453     } catch (std::exception& e) {
68454       {
68455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68456       };
68457     } catch (Dali::DaliException e) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68460       };
68461     } catch (...) {
68462       {
68463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68464       };
68465     }
68466   }
68467
68468 }
68469
68470
68471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68472   void * jresult ;
68473   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68474   Dali::Toolkit::Control result;
68475
68476   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68477   {
68478     try {
68479       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68480     } catch (std::out_of_range& e) {
68481       {
68482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (std::exception& e) {
68485       {
68486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (Dali::DaliException e) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498
68499   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68505   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68506   Dali::Toolkit::Control arg2 ;
68507   Dali::Toolkit::Control *argp2 ;
68508
68509   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68510   argp2 = (Dali::Toolkit::Control *)jarg2;
68511   if (!argp2) {
68512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68513     return ;
68514   }
68515   arg2 = *argp2;
68516   {
68517     try {
68518       (arg1)->RemoveFocus(arg2);
68519     } catch (std::out_of_range& e) {
68520       {
68521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68522       };
68523     } catch (std::exception& e) {
68524       {
68525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68526       };
68527     } catch (Dali::DaliException e) {
68528       {
68529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68530       };
68531     } catch (...) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68534       };
68535     }
68536   }
68537
68538 }
68539
68540
68541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68542   void * jresult ;
68543   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68544   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68545
68546   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68547   {
68548     try {
68549       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68550     } catch (std::out_of_range& e) {
68551       {
68552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (std::exception& e) {
68555       {
68556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68557       };
68558     } catch (Dali::DaliException e) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68561       };
68562     } catch (...) {
68563       {
68564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68565       };
68566     }
68567   }
68568
68569   jresult = (void *)result;
68570   return jresult;
68571 }
68572
68573
68574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68575   void * jresult ;
68576   Dali::Toolkit::Alignment::Padding *result = 0 ;
68577
68578   {
68579     try {
68580       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68581     } catch (std::out_of_range& e) {
68582       {
68583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68584       };
68585     } catch (std::exception& e) {
68586       {
68587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68588       };
68589     } catch (Dali::DaliException e) {
68590       {
68591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68592       };
68593     } catch (...) {
68594       {
68595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68596       };
68597     }
68598   }
68599
68600   jresult = (void *)result;
68601   return jresult;
68602 }
68603
68604
68605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68606   void * jresult ;
68607   float arg1 ;
68608   float arg2 ;
68609   float arg3 ;
68610   float arg4 ;
68611   Dali::Toolkit::Alignment::Padding *result = 0 ;
68612
68613   arg1 = (float)jarg1;
68614   arg2 = (float)jarg2;
68615   arg3 = (float)jarg3;
68616   arg4 = (float)jarg4;
68617   {
68618     try {
68619       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68620     } catch (std::out_of_range& e) {
68621       {
68622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (std::exception& e) {
68625       {
68626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68627       };
68628     } catch (Dali::DaliException e) {
68629       {
68630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68631       };
68632     } catch (...) {
68633       {
68634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68635       };
68636     }
68637   }
68638
68639   jresult = (void *)result;
68640   return jresult;
68641 }
68642
68643
68644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68645   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68646   float arg2 ;
68647
68648   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68649   arg2 = (float)jarg2;
68650   if (arg1) (arg1)->left = arg2;
68651 }
68652
68653
68654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68655   float jresult ;
68656   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68657   float result;
68658
68659   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68660   result = (float) ((arg1)->left);
68661   jresult = result;
68662   return jresult;
68663 }
68664
68665
68666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68667   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68668   float arg2 ;
68669
68670   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68671   arg2 = (float)jarg2;
68672   if (arg1) (arg1)->right = arg2;
68673 }
68674
68675
68676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68677   float jresult ;
68678   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68679   float result;
68680
68681   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68682   result = (float) ((arg1)->right);
68683   jresult = result;
68684   return jresult;
68685 }
68686
68687
68688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68689   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68690   float arg2 ;
68691
68692   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68693   arg2 = (float)jarg2;
68694   if (arg1) (arg1)->top = arg2;
68695 }
68696
68697
68698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68699   float jresult ;
68700   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68701   float result;
68702
68703   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68704   result = (float) ((arg1)->top);
68705   jresult = result;
68706   return jresult;
68707 }
68708
68709
68710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68711   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68712   float arg2 ;
68713
68714   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68715   arg2 = (float)jarg2;
68716   if (arg1) (arg1)->bottom = arg2;
68717 }
68718
68719
68720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68721   float jresult ;
68722   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68723   float result;
68724
68725   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68726   result = (float) ((arg1)->bottom);
68727   jresult = result;
68728   return jresult;
68729 }
68730
68731
68732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68733   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68734
68735   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68736   {
68737     try {
68738       delete arg1;
68739     } catch (std::out_of_range& e) {
68740       {
68741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68742       };
68743     } catch (std::exception& e) {
68744       {
68745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68746       };
68747     } catch (Dali::DaliException e) {
68748       {
68749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68750       };
68751     } catch (...) {
68752       {
68753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68754       };
68755     }
68756   }
68757
68758 }
68759
68760
68761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68762   void * jresult ;
68763   Dali::Toolkit::Alignment *result = 0 ;
68764
68765   {
68766     try {
68767       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68768     } catch (std::out_of_range& e) {
68769       {
68770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (std::exception& e) {
68773       {
68774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (Dali::DaliException e) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786
68787   jresult = (void *)result;
68788   return jresult;
68789 }
68790
68791
68792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68793   void * jresult ;
68794   Dali::Toolkit::Alignment::Type arg1 ;
68795   Dali::Toolkit::Alignment::Type arg2 ;
68796   Dali::Toolkit::Alignment result;
68797
68798   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68799   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68800   {
68801     try {
68802       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68803     } catch (std::out_of_range& e) {
68804       {
68805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68806       };
68807     } catch (std::exception& e) {
68808       {
68809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68810       };
68811     } catch (Dali::DaliException e) {
68812       {
68813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68814       };
68815     } catch (...) {
68816       {
68817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68818       };
68819     }
68820   }
68821
68822   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68823   return jresult;
68824 }
68825
68826
68827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68828   void * jresult ;
68829   Dali::Toolkit::Alignment::Type arg1 ;
68830   Dali::Toolkit::Alignment result;
68831
68832   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68833   {
68834     try {
68835       result = Dali::Toolkit::Alignment::New(arg1);
68836     } catch (std::out_of_range& e) {
68837       {
68838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (std::exception& e) {
68841       {
68842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68843       };
68844     } catch (Dali::DaliException e) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68847       };
68848     } catch (...) {
68849       {
68850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68851       };
68852     }
68853   }
68854
68855   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68856   return jresult;
68857 }
68858
68859
68860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68861   void * jresult ;
68862   Dali::Toolkit::Alignment result;
68863
68864   {
68865     try {
68866       result = Dali::Toolkit::Alignment::New();
68867     } catch (std::out_of_range& e) {
68868       {
68869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (std::exception& e) {
68872       {
68873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68874       };
68875     } catch (Dali::DaliException e) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68882       };
68883     }
68884   }
68885
68886   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68887   return jresult;
68888 }
68889
68890
68891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68892   void * jresult ;
68893   Dali::Toolkit::Alignment *arg1 = 0 ;
68894   Dali::Toolkit::Alignment *result = 0 ;
68895
68896   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68897   if (!arg1) {
68898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68899     return 0;
68900   }
68901   {
68902     try {
68903       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68904     } catch (std::out_of_range& e) {
68905       {
68906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68907       };
68908     } catch (std::exception& e) {
68909       {
68910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68911       };
68912     } catch (Dali::DaliException e) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68915       };
68916     } catch (...) {
68917       {
68918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68919       };
68920     }
68921   }
68922
68923   jresult = (void *)result;
68924   return jresult;
68925 }
68926
68927
68928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68929   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68930
68931   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68932   {
68933     try {
68934       delete arg1;
68935     } catch (std::out_of_range& e) {
68936       {
68937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (std::exception& e) {
68940       {
68941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68942       };
68943     } catch (Dali::DaliException e) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68946       };
68947     } catch (...) {
68948       {
68949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68950       };
68951     }
68952   }
68953
68954 }
68955
68956
68957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68958   void * jresult ;
68959   Dali::BaseHandle arg1 ;
68960   Dali::BaseHandle *argp1 ;
68961   Dali::Toolkit::Alignment result;
68962
68963   argp1 = (Dali::BaseHandle *)jarg1;
68964   if (!argp1) {
68965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68966     return 0;
68967   }
68968   arg1 = *argp1;
68969   {
68970     try {
68971       result = Dali::Toolkit::Alignment::DownCast(arg1);
68972     } catch (std::out_of_range& e) {
68973       {
68974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68975       };
68976     } catch (std::exception& e) {
68977       {
68978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68979       };
68980     } catch (Dali::DaliException e) {
68981       {
68982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68983       };
68984     } catch (...) {
68985       {
68986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68987       };
68988     }
68989   }
68990
68991   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68997   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68998   Dali::Toolkit::Alignment::Type arg2 ;
68999
69000   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69001   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69002   {
69003     try {
69004       (arg1)->SetAlignmentType(arg2);
69005     } catch (std::out_of_range& e) {
69006       {
69007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69008       };
69009     } catch (std::exception& e) {
69010       {
69011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69012       };
69013     } catch (Dali::DaliException e) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69016       };
69017     } catch (...) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69020       };
69021     }
69022   }
69023
69024 }
69025
69026
69027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69028   int jresult ;
69029   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69030   Dali::Toolkit::Alignment::Type result;
69031
69032   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69033   {
69034     try {
69035       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69036     } catch (std::out_of_range& e) {
69037       {
69038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (std::exception& e) {
69041       {
69042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69043       };
69044     } catch (Dali::DaliException e) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69047       };
69048     } catch (...) {
69049       {
69050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69051       };
69052     }
69053   }
69054
69055   jresult = (int)result;
69056   return jresult;
69057 }
69058
69059
69060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69061   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69062   Dali::Toolkit::Alignment::Scaling arg2 ;
69063
69064   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69065   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69066   {
69067     try {
69068       (arg1)->SetScaling(arg2);
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69076       };
69077     } catch (Dali::DaliException e) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69080       };
69081     } catch (...) {
69082       {
69083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69084       };
69085     }
69086   }
69087
69088 }
69089
69090
69091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69092   int jresult ;
69093   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69094   Dali::Toolkit::Alignment::Scaling result;
69095
69096   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69097   {
69098     try {
69099       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69100     } catch (std::out_of_range& e) {
69101       {
69102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (std::exception& e) {
69105       {
69106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69107       };
69108     } catch (Dali::DaliException e) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69111       };
69112     } catch (...) {
69113       {
69114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69115       };
69116     }
69117   }
69118
69119   jresult = (int)result;
69120   return jresult;
69121 }
69122
69123
69124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69125   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69126   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69127
69128   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69129   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69130   if (!arg2) {
69131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69132     return ;
69133   }
69134   {
69135     try {
69136       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69137     } catch (std::out_of_range& e) {
69138       {
69139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69140       };
69141     } catch (std::exception& e) {
69142       {
69143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69144       };
69145     } catch (Dali::DaliException e) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69152       };
69153     }
69154   }
69155
69156 }
69157
69158
69159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69160   void * jresult ;
69161   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69162   Dali::Toolkit::Alignment::Padding *result = 0 ;
69163
69164   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69165   {
69166     try {
69167       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69168     } catch (std::out_of_range& e) {
69169       {
69170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (std::exception& e) {
69173       {
69174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (Dali::DaliException e) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69179       };
69180     } catch (...) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69183       };
69184     }
69185   }
69186
69187   jresult = (void *)result;
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69193   void * jresult ;
69194   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69195   Dali::Toolkit::Alignment *arg2 = 0 ;
69196   Dali::Toolkit::Alignment *result = 0 ;
69197
69198   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69199   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69200   if (!arg2) {
69201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69202     return 0;
69203   }
69204   {
69205     try {
69206       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (Dali::DaliException e) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225
69226   jresult = (void *)result;
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69232   int jresult ;
69233   int result;
69234
69235   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69236   jresult = (int)result;
69237   return jresult;
69238 }
69239
69240
69241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69242   int jresult ;
69243   int result;
69244
69245   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69246   jresult = (int)result;
69247   return jresult;
69248 }
69249
69250
69251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69252   int jresult ;
69253   int result;
69254
69255   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69256   jresult = (int)result;
69257   return jresult;
69258 }
69259
69260
69261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69262   int jresult ;
69263   int result;
69264
69265   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69266   jresult = (int)result;
69267   return jresult;
69268 }
69269
69270
69271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69272   int jresult ;
69273   int result;
69274
69275   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69276   jresult = (int)result;
69277   return jresult;
69278 }
69279
69280
69281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69282   int jresult ;
69283   int result;
69284
69285   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69286   jresult = (int)result;
69287   return jresult;
69288 }
69289
69290
69291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69292   int jresult ;
69293   int result;
69294
69295   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69296   jresult = (int)result;
69297   return jresult;
69298 }
69299
69300
69301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69302   int jresult ;
69303   int result;
69304
69305   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69306   jresult = (int)result;
69307   return jresult;
69308 }
69309
69310
69311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69312   int jresult ;
69313   int result;
69314
69315   result = (int)Dali::Toolkit::Button::Property::LABEL;
69316   jresult = (int)result;
69317   return jresult;
69318 }
69319
69320
69321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69322   int jresult ;
69323   int result;
69324
69325   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69326   jresult = (int)result;
69327   return jresult;
69328 }
69329
69330
69331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69332   void * jresult ;
69333   Dali::Toolkit::Button::Property *result = 0 ;
69334
69335   {
69336     try {
69337       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69338     } catch (std::out_of_range& e) {
69339       {
69340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69341       };
69342     } catch (std::exception& e) {
69343       {
69344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (Dali::DaliException e) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69349       };
69350     } catch (...) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69353       };
69354     }
69355   }
69356
69357   jresult = (void *)result;
69358   return jresult;
69359 }
69360
69361
69362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69363   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69364
69365   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69366   {
69367     try {
69368       delete arg1;
69369     } catch (std::out_of_range& e) {
69370       {
69371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69372       };
69373     } catch (std::exception& e) {
69374       {
69375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69376       };
69377     } catch (Dali::DaliException e) {
69378       {
69379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69380       };
69381     } catch (...) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69384       };
69385     }
69386   }
69387
69388 }
69389
69390
69391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69392   void * jresult ;
69393   Dali::Toolkit::Button *result = 0 ;
69394
69395   {
69396     try {
69397       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69398     } catch (std::out_of_range& e) {
69399       {
69400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69401       };
69402     } catch (std::exception& e) {
69403       {
69404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69405       };
69406     } catch (Dali::DaliException e) {
69407       {
69408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69409       };
69410     } catch (...) {
69411       {
69412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69413       };
69414     }
69415   }
69416
69417   jresult = (void *)result;
69418   return jresult;
69419 }
69420
69421
69422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69423   void * jresult ;
69424   Dali::Toolkit::Button *arg1 = 0 ;
69425   Dali::Toolkit::Button *result = 0 ;
69426
69427   arg1 = (Dali::Toolkit::Button *)jarg1;
69428   if (!arg1) {
69429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69430     return 0;
69431   }
69432   {
69433     try {
69434       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69435     } catch (std::out_of_range& e) {
69436       {
69437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69438       };
69439     } catch (std::exception& e) {
69440       {
69441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69442       };
69443     } catch (Dali::DaliException e) {
69444       {
69445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69446       };
69447     } catch (...) {
69448       {
69449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69450       };
69451     }
69452   }
69453
69454   jresult = (void *)result;
69455   return jresult;
69456 }
69457
69458
69459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69460   void * jresult ;
69461   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69462   Dali::Toolkit::Button *arg2 = 0 ;
69463   Dali::Toolkit::Button *result = 0 ;
69464
69465   arg1 = (Dali::Toolkit::Button *)jarg1;
69466   arg2 = (Dali::Toolkit::Button *)jarg2;
69467   if (!arg2) {
69468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69469     return 0;
69470   }
69471   {
69472     try {
69473       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69474     } catch (std::out_of_range& e) {
69475       {
69476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (std::exception& e) {
69479       {
69480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69481       };
69482     } catch (Dali::DaliException e) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69485       };
69486     } catch (...) {
69487       {
69488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69489       };
69490     }
69491   }
69492
69493   jresult = (void *)result;
69494   return jresult;
69495 }
69496
69497
69498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69499   void * jresult ;
69500   Dali::BaseHandle arg1 ;
69501   Dali::BaseHandle *argp1 ;
69502   Dali::Toolkit::Button result;
69503
69504   argp1 = (Dali::BaseHandle *)jarg1;
69505   if (!argp1) {
69506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69507     return 0;
69508   }
69509   arg1 = *argp1;
69510   {
69511     try {
69512       result = Dali::Toolkit::Button::DownCast(arg1);
69513     } catch (std::out_of_range& e) {
69514       {
69515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69516       };
69517     } catch (std::exception& e) {
69518       {
69519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69520       };
69521     } catch (Dali::DaliException e) {
69522       {
69523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69524       };
69525     } catch (...) {
69526       {
69527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69528       };
69529     }
69530   }
69531
69532   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69533   return jresult;
69534 }
69535
69536
69537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69538   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69539
69540   arg1 = (Dali::Toolkit::Button *)jarg1;
69541   {
69542     try {
69543       delete arg1;
69544     } catch (std::out_of_range& e) {
69545       {
69546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69547       };
69548     } catch (std::exception& e) {
69549       {
69550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69551       };
69552     } catch (Dali::DaliException e) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69555       };
69556     } catch (...) {
69557       {
69558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69559       };
69560     }
69561   }
69562
69563 }
69564
69565
69566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69567   unsigned int jresult ;
69568   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69569   bool result;
69570
69571   arg1 = (Dali::Toolkit::Button *)jarg1;
69572   {
69573     try {
69574       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69575     } catch (std::out_of_range& e) {
69576       {
69577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (std::exception& e) {
69580       {
69581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69582       };
69583     } catch (Dali::DaliException e) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69586       };
69587     } catch (...) {
69588       {
69589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69590       };
69591     }
69592   }
69593
69594   jresult = result;
69595   return jresult;
69596 }
69597
69598
69599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69600   unsigned int jresult ;
69601   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69602   bool result;
69603
69604   arg1 = (Dali::Toolkit::Button *)jarg1;
69605   {
69606     try {
69607       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69608     } catch (std::out_of_range& e) {
69609       {
69610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69611       };
69612     } catch (std::exception& e) {
69613       {
69614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69615       };
69616     } catch (Dali::DaliException e) {
69617       {
69618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69619       };
69620     } catch (...) {
69621       {
69622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69623       };
69624     }
69625   }
69626
69627   jresult = result;
69628   return jresult;
69629 }
69630
69631
69632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69633   float jresult ;
69634   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69635   float result;
69636
69637   arg1 = (Dali::Toolkit::Button *)jarg1;
69638   {
69639     try {
69640       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69648       };
69649     } catch (Dali::DaliException e) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69652       };
69653     } catch (...) {
69654       {
69655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69656       };
69657     }
69658   }
69659
69660   jresult = result;
69661   return jresult;
69662 }
69663
69664
69665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69666   float jresult ;
69667   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69668   float result;
69669
69670   arg1 = (Dali::Toolkit::Button *)jarg1;
69671   {
69672     try {
69673       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69674     } catch (std::out_of_range& e) {
69675       {
69676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69677       };
69678     } catch (std::exception& e) {
69679       {
69680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69681       };
69682     } catch (Dali::DaliException e) {
69683       {
69684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69685       };
69686     } catch (...) {
69687       {
69688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69689       };
69690     }
69691   }
69692
69693   jresult = result;
69694   return jresult;
69695 }
69696
69697
69698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69699   unsigned int jresult ;
69700   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69701   bool result;
69702
69703   arg1 = (Dali::Toolkit::Button *)jarg1;
69704   {
69705     try {
69706       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69707     } catch (std::out_of_range& e) {
69708       {
69709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (std::exception& e) {
69712       {
69713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69714       };
69715     } catch (Dali::DaliException e) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69718       };
69719     } catch (...) {
69720       {
69721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69722       };
69723     }
69724   }
69725
69726   jresult = result;
69727   return jresult;
69728 }
69729
69730
69731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69732   unsigned int jresult ;
69733   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69734   bool result;
69735
69736   arg1 = (Dali::Toolkit::Button *)jarg1;
69737   {
69738     try {
69739       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69740     } catch (std::out_of_range& e) {
69741       {
69742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69743       };
69744     } catch (std::exception& e) {
69745       {
69746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69747       };
69748     } catch (Dali::DaliException e) {
69749       {
69750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69751       };
69752     } catch (...) {
69753       {
69754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69755       };
69756     }
69757   }
69758
69759   jresult = result;
69760   return jresult;
69761 }
69762
69763
69764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69765   float jresult ;
69766   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69767   float result;
69768
69769   arg1 = (Dali::Toolkit::Button *)jarg1;
69770   {
69771     try {
69772       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69773     } catch (std::out_of_range& e) {
69774       {
69775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (std::exception& e) {
69778       {
69779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69780       };
69781     } catch (Dali::DaliException e) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69788       };
69789     }
69790   }
69791
69792   jresult = result;
69793   return jresult;
69794 }
69795
69796
69797 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69798   char * jresult ;
69799   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69800   std::string result;
69801
69802   arg1 = (Dali::Toolkit::Button *)jarg1;
69803   {
69804     try {
69805       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69806     } catch (std::out_of_range& e) {
69807       {
69808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (std::exception& e) {
69811       {
69812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69813       };
69814     } catch (Dali::DaliException e) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69817       };
69818     } catch (...) {
69819       {
69820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69821       };
69822     }
69823   }
69824
69825   jresult = SWIG_csharp_string_callback((&result)->c_str());
69826   return jresult;
69827 }
69828
69829
69830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69831   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69832   Dali::Actor arg2 ;
69833   Dali::Actor *argp2 ;
69834
69835   arg1 = (Dali::Toolkit::Button *)jarg1;
69836   argp2 = (Dali::Actor *)jarg2;
69837   if (!argp2) {
69838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69839     return ;
69840   }
69841   arg2 = *argp2;
69842   {
69843     try {
69844       (arg1)->SetLabel(arg2);
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69852       };
69853     } catch (Dali::DaliException e) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69856       };
69857     } catch (...) {
69858       {
69859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69860       };
69861     }
69862   }
69863
69864 }
69865
69866
69867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69868   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69869   Dali::Image arg2 ;
69870   Dali::Image *argp2 ;
69871
69872   arg1 = (Dali::Toolkit::Button *)jarg1;
69873   argp2 = (Dali::Image *)jarg2;
69874   if (!argp2) {
69875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69876     return ;
69877   }
69878   arg2 = *argp2;
69879   {
69880     try {
69881       (arg1)->SetButtonImage(arg2);
69882     } catch (std::out_of_range& e) {
69883       {
69884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69885       };
69886     } catch (std::exception& e) {
69887       {
69888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69889       };
69890     } catch (Dali::DaliException e) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69893       };
69894     } catch (...) {
69895       {
69896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69897       };
69898     }
69899   }
69900
69901 }
69902
69903
69904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69905   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69906   Dali::Image arg2 ;
69907   Dali::Image *argp2 ;
69908
69909   arg1 = (Dali::Toolkit::Button *)jarg1;
69910   argp2 = (Dali::Image *)jarg2;
69911   if (!argp2) {
69912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69913     return ;
69914   }
69915   arg2 = *argp2;
69916   {
69917     try {
69918       (arg1)->SetSelectedImage(arg2);
69919     } catch (std::out_of_range& e) {
69920       {
69921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69922       };
69923     } catch (std::exception& e) {
69924       {
69925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69926       };
69927     } catch (Dali::DaliException e) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69930       };
69931     } catch (...) {
69932       {
69933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69934       };
69935     }
69936   }
69937
69938 }
69939
69940
69941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69942   void * jresult ;
69943   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69944   Dali::Actor result;
69945
69946   arg1 = (Dali::Toolkit::Button *)jarg1;
69947   {
69948     try {
69949       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69950     } catch (std::out_of_range& e) {
69951       {
69952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (std::exception& e) {
69955       {
69956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69957       };
69958     } catch (Dali::DaliException e) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69961       };
69962     } catch (...) {
69963       {
69964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69965       };
69966     }
69967   }
69968
69969   jresult = new Dali::Actor((const Dali::Actor &)result);
69970   return jresult;
69971 }
69972
69973
69974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69975   void * jresult ;
69976   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69977   Dali::Actor result;
69978
69979   arg1 = (Dali::Toolkit::Button *)jarg1;
69980   {
69981     try {
69982       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69983     } catch (std::out_of_range& e) {
69984       {
69985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69986       };
69987     } catch (std::exception& e) {
69988       {
69989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69990       };
69991     } catch (Dali::DaliException e) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69994       };
69995     } catch (...) {
69996       {
69997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69998       };
69999     }
70000   }
70001
70002   jresult = new Dali::Actor((const Dali::Actor &)result);
70003   return jresult;
70004 }
70005
70006
70007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70008   void * jresult ;
70009   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70010   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70011
70012   arg1 = (Dali::Toolkit::Button *)jarg1;
70013   {
70014     try {
70015       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70016     } catch (std::out_of_range& e) {
70017       {
70018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70019       };
70020     } catch (std::exception& e) {
70021       {
70022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70023       };
70024     } catch (Dali::DaliException e) {
70025       {
70026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70027       };
70028     } catch (...) {
70029       {
70030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70031       };
70032     }
70033   }
70034
70035   jresult = (void *)result;
70036   return jresult;
70037 }
70038
70039
70040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70041   void * jresult ;
70042   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70043   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70044
70045   arg1 = (Dali::Toolkit::Button *)jarg1;
70046   {
70047     try {
70048       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (Dali::DaliException e) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70060       };
70061     } catch (...) {
70062       {
70063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70064       };
70065     }
70066   }
70067
70068   jresult = (void *)result;
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70074   void * jresult ;
70075   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70076   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70077
70078   arg1 = (Dali::Toolkit::Button *)jarg1;
70079   {
70080     try {
70081       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70082     } catch (std::out_of_range& e) {
70083       {
70084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70085       };
70086     } catch (std::exception& e) {
70087       {
70088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (Dali::DaliException e) {
70091       {
70092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70093       };
70094     } catch (...) {
70095       {
70096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70097       };
70098     }
70099   }
70100
70101   jresult = (void *)result;
70102   return jresult;
70103 }
70104
70105
70106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70107   void * jresult ;
70108   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70109   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70110
70111   arg1 = (Dali::Toolkit::Button *)jarg1;
70112   {
70113     try {
70114       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70115     } catch (std::out_of_range& e) {
70116       {
70117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70118       };
70119     } catch (std::exception& e) {
70120       {
70121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70122       };
70123     } catch (Dali::DaliException e) {
70124       {
70125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70126       };
70127     } catch (...) {
70128       {
70129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70130       };
70131     }
70132   }
70133
70134   jresult = (void *)result;
70135   return jresult;
70136 }
70137
70138
70139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70140   void * jresult ;
70141   Dali::Toolkit::CheckBoxButton *result = 0 ;
70142
70143   {
70144     try {
70145       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70146     } catch (std::out_of_range& e) {
70147       {
70148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (std::exception& e) {
70151       {
70152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70153       };
70154     } catch (Dali::DaliException e) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70157       };
70158     } catch (...) {
70159       {
70160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70161       };
70162     }
70163   }
70164
70165   jresult = (void *)result;
70166   return jresult;
70167 }
70168
70169
70170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70171   void * jresult ;
70172   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70173   Dali::Toolkit::CheckBoxButton *result = 0 ;
70174
70175   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70176   if (!arg1) {
70177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70178     return 0;
70179   }
70180   {
70181     try {
70182       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70183     } catch (std::out_of_range& e) {
70184       {
70185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70186       };
70187     } catch (std::exception& e) {
70188       {
70189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (Dali::DaliException e) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70194       };
70195     } catch (...) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70198       };
70199     }
70200   }
70201
70202   jresult = (void *)result;
70203   return jresult;
70204 }
70205
70206
70207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70208   void * jresult ;
70209   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70210   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70211   Dali::Toolkit::CheckBoxButton *result = 0 ;
70212
70213   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70214   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70215   if (!arg2) {
70216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70217     return 0;
70218   }
70219   {
70220     try {
70221       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70222     } catch (std::out_of_range& e) {
70223       {
70224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (std::exception& e) {
70227       {
70228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70229       };
70230     } catch (Dali::DaliException e) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70233       };
70234     } catch (...) {
70235       {
70236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70237       };
70238     }
70239   }
70240
70241   jresult = (void *)result;
70242   return jresult;
70243 }
70244
70245
70246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70247   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70248
70249   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70250   {
70251     try {
70252       delete arg1;
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70260       };
70261     } catch (Dali::DaliException e) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70264       };
70265     } catch (...) {
70266       {
70267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70268       };
70269     }
70270   }
70271
70272 }
70273
70274
70275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70276   void * jresult ;
70277   Dali::Toolkit::CheckBoxButton result;
70278
70279   {
70280     try {
70281       result = Dali::Toolkit::CheckBoxButton::New();
70282     } catch (std::out_of_range& e) {
70283       {
70284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (std::exception& e) {
70287       {
70288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70289       };
70290     } catch (Dali::DaliException e) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70293       };
70294     } catch (...) {
70295       {
70296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70297       };
70298     }
70299   }
70300
70301   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70302   return jresult;
70303 }
70304
70305
70306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70307   void * jresult ;
70308   Dali::BaseHandle arg1 ;
70309   Dali::BaseHandle *argp1 ;
70310   Dali::Toolkit::CheckBoxButton result;
70311
70312   argp1 = (Dali::BaseHandle *)jarg1;
70313   if (!argp1) {
70314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70315     return 0;
70316   }
70317   arg1 = *argp1;
70318   {
70319     try {
70320       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70321     } catch (std::out_of_range& e) {
70322       {
70323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70324       };
70325     } catch (std::exception& e) {
70326       {
70327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70328       };
70329     } catch (Dali::DaliException e) {
70330       {
70331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70332       };
70333     } catch (...) {
70334       {
70335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70336       };
70337     }
70338   }
70339
70340   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70341   return jresult;
70342 }
70343
70344
70345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70346   int jresult ;
70347   int result;
70348
70349   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70350   jresult = (int)result;
70351   return jresult;
70352 }
70353
70354
70355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70356   int jresult ;
70357   int result;
70358
70359   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70360   jresult = (int)result;
70361   return jresult;
70362 }
70363
70364
70365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70366   int jresult ;
70367   int result;
70368
70369   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70370   jresult = (int)result;
70371   return jresult;
70372 }
70373
70374
70375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70376   int jresult ;
70377   int result;
70378
70379   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70380   jresult = (int)result;
70381   return jresult;
70382 }
70383
70384
70385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70386   int jresult ;
70387   int result;
70388
70389   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70390   jresult = (int)result;
70391   return jresult;
70392 }
70393
70394
70395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70396   void * jresult ;
70397   Dali::Toolkit::PushButton::Property *result = 0 ;
70398
70399   {
70400     try {
70401       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70402     } catch (std::out_of_range& e) {
70403       {
70404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70405       };
70406     } catch (std::exception& e) {
70407       {
70408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70409       };
70410     } catch (Dali::DaliException e) {
70411       {
70412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70413       };
70414     } catch (...) {
70415       {
70416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70417       };
70418     }
70419   }
70420
70421   jresult = (void *)result;
70422   return jresult;
70423 }
70424
70425
70426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70427   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70428
70429   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70430   {
70431     try {
70432       delete arg1;
70433     } catch (std::out_of_range& e) {
70434       {
70435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70436       };
70437     } catch (std::exception& e) {
70438       {
70439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70440       };
70441     } catch (Dali::DaliException e) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70444       };
70445     } catch (...) {
70446       {
70447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70448       };
70449     }
70450   }
70451
70452 }
70453
70454
70455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70456   void * jresult ;
70457   Dali::Toolkit::PushButton *result = 0 ;
70458
70459   {
70460     try {
70461       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70462     } catch (std::out_of_range& e) {
70463       {
70464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (std::exception& e) {
70467       {
70468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70469       };
70470     } catch (Dali::DaliException e) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70473       };
70474     } catch (...) {
70475       {
70476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70477       };
70478     }
70479   }
70480
70481   jresult = (void *)result;
70482   return jresult;
70483 }
70484
70485
70486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70487   void * jresult ;
70488   Dali::Toolkit::PushButton *arg1 = 0 ;
70489   Dali::Toolkit::PushButton *result = 0 ;
70490
70491   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70492   if (!arg1) {
70493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70494     return 0;
70495   }
70496   {
70497     try {
70498       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70499     } catch (std::out_of_range& e) {
70500       {
70501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70502       };
70503     } catch (std::exception& e) {
70504       {
70505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70506       };
70507     } catch (Dali::DaliException e) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70510       };
70511     } catch (...) {
70512       {
70513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70514       };
70515     }
70516   }
70517
70518   jresult = (void *)result;
70519   return jresult;
70520 }
70521
70522
70523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70524   void * jresult ;
70525   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70526   Dali::Toolkit::PushButton *arg2 = 0 ;
70527   Dali::Toolkit::PushButton *result = 0 ;
70528
70529   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70530   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70531   if (!arg2) {
70532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70533     return 0;
70534   }
70535   {
70536     try {
70537       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70538     } catch (std::out_of_range& e) {
70539       {
70540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70541       };
70542     } catch (std::exception& e) {
70543       {
70544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70545       };
70546     } catch (Dali::DaliException e) {
70547       {
70548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70549       };
70550     } catch (...) {
70551       {
70552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70553       };
70554     }
70555   }
70556
70557   jresult = (void *)result;
70558   return jresult;
70559 }
70560
70561
70562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70563   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70564
70565   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70566   {
70567     try {
70568       delete arg1;
70569     } catch (std::out_of_range& e) {
70570       {
70571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (std::exception& e) {
70574       {
70575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (Dali::DaliException e) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70584       };
70585     }
70586   }
70587
70588 }
70589
70590
70591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70592   void * jresult ;
70593   Dali::Toolkit::PushButton result;
70594
70595   {
70596     try {
70597       result = Dali::Toolkit::PushButton::New();
70598     } catch (std::out_of_range& e) {
70599       {
70600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70601       };
70602     } catch (std::exception& e) {
70603       {
70604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70605       };
70606     } catch (Dali::DaliException e) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70609       };
70610     } catch (...) {
70611       {
70612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70613       };
70614     }
70615   }
70616
70617   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70618   return jresult;
70619 }
70620
70621
70622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70623   void * jresult ;
70624   Dali::BaseHandle arg1 ;
70625   Dali::BaseHandle *argp1 ;
70626   Dali::Toolkit::PushButton result;
70627
70628   argp1 = (Dali::BaseHandle *)jarg1;
70629   if (!argp1) {
70630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70631     return 0;
70632   }
70633   arg1 = *argp1;
70634   {
70635     try {
70636       result = Dali::Toolkit::PushButton::DownCast(arg1);
70637     } catch (std::out_of_range& e) {
70638       {
70639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70640       };
70641     } catch (std::exception& e) {
70642       {
70643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70644       };
70645     } catch (Dali::DaliException e) {
70646       {
70647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70648       };
70649     } catch (...) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70652       };
70653     }
70654   }
70655
70656   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70657   return jresult;
70658 }
70659
70660
70661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70662   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70663   Dali::Image arg2 ;
70664   Dali::Image *argp2 ;
70665
70666   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70667   argp2 = (Dali::Image *)jarg2;
70668   if (!argp2) {
70669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70670     return ;
70671   }
70672   arg2 = *argp2;
70673   {
70674     try {
70675       (arg1)->SetButtonImage(arg2);
70676     } catch (std::out_of_range& e) {
70677       {
70678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70679       };
70680     } catch (std::exception& e) {
70681       {
70682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70683       };
70684     } catch (Dali::DaliException e) {
70685       {
70686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70687       };
70688     } catch (...) {
70689       {
70690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70691       };
70692     }
70693   }
70694
70695 }
70696
70697
70698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70699   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70700   Dali::Actor arg2 ;
70701   Dali::Actor *argp2 ;
70702
70703   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70704   argp2 = (Dali::Actor *)jarg2;
70705   if (!argp2) {
70706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70707     return ;
70708   }
70709   arg2 = *argp2;
70710   {
70711     try {
70712       (arg1)->SetButtonImage(arg2);
70713     } catch (std::out_of_range& e) {
70714       {
70715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70716       };
70717     } catch (std::exception& e) {
70718       {
70719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70720       };
70721     } catch (Dali::DaliException e) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70724       };
70725     } catch (...) {
70726       {
70727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70728       };
70729     }
70730   }
70731
70732 }
70733
70734
70735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70736   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70737   Dali::Actor arg2 ;
70738   Dali::Actor *argp2 ;
70739
70740   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70741   argp2 = (Dali::Actor *)jarg2;
70742   if (!argp2) {
70743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70744     return ;
70745   }
70746   arg2 = *argp2;
70747   {
70748     try {
70749       (arg1)->SetBackgroundImage(arg2);
70750     } catch (std::out_of_range& e) {
70751       {
70752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70753       };
70754     } catch (std::exception& e) {
70755       {
70756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70757       };
70758     } catch (Dali::DaliException e) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70761       };
70762     } catch (...) {
70763       {
70764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70765       };
70766     }
70767   }
70768
70769 }
70770
70771
70772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70773   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70774   Dali::Image arg2 ;
70775   Dali::Image *argp2 ;
70776
70777   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70778   argp2 = (Dali::Image *)jarg2;
70779   if (!argp2) {
70780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70781     return ;
70782   }
70783   arg2 = *argp2;
70784   {
70785     try {
70786       (arg1)->SetSelectedImage(arg2);
70787     } catch (std::out_of_range& e) {
70788       {
70789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70790       };
70791     } catch (std::exception& e) {
70792       {
70793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70794       };
70795     } catch (Dali::DaliException e) {
70796       {
70797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70798       };
70799     } catch (...) {
70800       {
70801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70802       };
70803     }
70804   }
70805
70806 }
70807
70808
70809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70810   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70811   Dali::Actor arg2 ;
70812   Dali::Actor *argp2 ;
70813
70814   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70815   argp2 = (Dali::Actor *)jarg2;
70816   if (!argp2) {
70817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70818     return ;
70819   }
70820   arg2 = *argp2;
70821   {
70822     try {
70823       (arg1)->SetSelectedImage(arg2);
70824     } catch (std::out_of_range& e) {
70825       {
70826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70827       };
70828     } catch (std::exception& e) {
70829       {
70830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70831       };
70832     } catch (Dali::DaliException e) {
70833       {
70834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70835       };
70836     } catch (...) {
70837       {
70838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70839       };
70840     }
70841   }
70842
70843 }
70844
70845
70846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70847   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70848   Dali::Actor arg2 ;
70849   Dali::Actor *argp2 ;
70850
70851   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70852   argp2 = (Dali::Actor *)jarg2;
70853   if (!argp2) {
70854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70855     return ;
70856   }
70857   arg2 = *argp2;
70858   {
70859     try {
70860       (arg1)->SetSelectedBackgroundImage(arg2);
70861     } catch (std::out_of_range& e) {
70862       {
70863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70864       };
70865     } catch (std::exception& e) {
70866       {
70867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70868       };
70869     } catch (Dali::DaliException e) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70872       };
70873     } catch (...) {
70874       {
70875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70876       };
70877     }
70878   }
70879
70880 }
70881
70882
70883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70884   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70885   Dali::Actor arg2 ;
70886   Dali::Actor *argp2 ;
70887
70888   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70889   argp2 = (Dali::Actor *)jarg2;
70890   if (!argp2) {
70891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70892     return ;
70893   }
70894   arg2 = *argp2;
70895   {
70896     try {
70897       (arg1)->SetDisabledBackgroundImage(arg2);
70898     } catch (std::out_of_range& e) {
70899       {
70900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70901       };
70902     } catch (std::exception& e) {
70903       {
70904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70905       };
70906     } catch (Dali::DaliException e) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70909       };
70910     } catch (...) {
70911       {
70912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70913       };
70914     }
70915   }
70916
70917 }
70918
70919
70920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70921   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70922   Dali::Actor arg2 ;
70923   Dali::Actor *argp2 ;
70924
70925   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70926   argp2 = (Dali::Actor *)jarg2;
70927   if (!argp2) {
70928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70929     return ;
70930   }
70931   arg2 = *argp2;
70932   {
70933     try {
70934       (arg1)->SetDisabledImage(arg2);
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70950       };
70951     }
70952   }
70953
70954 }
70955
70956
70957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70958   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70959   Dali::Actor arg2 ;
70960   Dali::Actor *argp2 ;
70961
70962   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70963   argp2 = (Dali::Actor *)jarg2;
70964   if (!argp2) {
70965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70966     return ;
70967   }
70968   arg2 = *argp2;
70969   {
70970     try {
70971       (arg1)->SetDisabledSelectedImage(arg2);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70987       };
70988     }
70989   }
70990
70991 }
70992
70993
70994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70995   void * jresult ;
70996   Dali::Toolkit::RadioButton *result = 0 ;
70997
70998   {
70999     try {
71000       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71001     } catch (std::out_of_range& e) {
71002       {
71003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71004       };
71005     } catch (std::exception& e) {
71006       {
71007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71008       };
71009     } catch (Dali::DaliException e) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71012       };
71013     } catch (...) {
71014       {
71015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71016       };
71017     }
71018   }
71019
71020   jresult = (void *)result;
71021   return jresult;
71022 }
71023
71024
71025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71026   void * jresult ;
71027   Dali::Toolkit::RadioButton *arg1 = 0 ;
71028   Dali::Toolkit::RadioButton *result = 0 ;
71029
71030   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71031   if (!arg1) {
71032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71033     return 0;
71034   }
71035   {
71036     try {
71037       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71038     } catch (std::out_of_range& e) {
71039       {
71040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (std::exception& e) {
71043       {
71044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (Dali::DaliException e) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71049       };
71050     } catch (...) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71053       };
71054     }
71055   }
71056
71057   jresult = (void *)result;
71058   return jresult;
71059 }
71060
71061
71062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71063   void * jresult ;
71064   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71065   Dali::Toolkit::RadioButton *arg2 = 0 ;
71066   Dali::Toolkit::RadioButton *result = 0 ;
71067
71068   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71069   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71070   if (!arg2) {
71071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71072     return 0;
71073   }
71074   {
71075     try {
71076       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71077     } catch (std::out_of_range& e) {
71078       {
71079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (std::exception& e) {
71082       {
71083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71084       };
71085     } catch (Dali::DaliException e) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71088       };
71089     } catch (...) {
71090       {
71091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71092       };
71093     }
71094   }
71095
71096   jresult = (void *)result;
71097   return jresult;
71098 }
71099
71100
71101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71102   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71103
71104   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71105   {
71106     try {
71107       delete arg1;
71108     } catch (std::out_of_range& e) {
71109       {
71110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71111       };
71112     } catch (std::exception& e) {
71113       {
71114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71115       };
71116     } catch (Dali::DaliException e) {
71117       {
71118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71119       };
71120     } catch (...) {
71121       {
71122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71123       };
71124     }
71125   }
71126
71127 }
71128
71129
71130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71131   void * jresult ;
71132   Dali::Toolkit::RadioButton result;
71133
71134   {
71135     try {
71136       result = Dali::Toolkit::RadioButton::New();
71137     } catch (std::out_of_range& e) {
71138       {
71139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (std::exception& e) {
71142       {
71143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71144       };
71145     } catch (Dali::DaliException e) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71148       };
71149     } catch (...) {
71150       {
71151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71152       };
71153     }
71154   }
71155
71156   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71157   return jresult;
71158 }
71159
71160
71161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71162   void * jresult ;
71163   std::string *arg1 = 0 ;
71164   Dali::Toolkit::RadioButton result;
71165
71166   if (!jarg1) {
71167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71168     return 0;
71169   }
71170   std::string arg1_str(jarg1);
71171   arg1 = &arg1_str;
71172   {
71173     try {
71174       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71175     } catch (std::out_of_range& e) {
71176       {
71177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (std::exception& e) {
71180       {
71181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71182       };
71183     } catch (Dali::DaliException e) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71186       };
71187     } catch (...) {
71188       {
71189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71190       };
71191     }
71192   }
71193
71194   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71195
71196   //argout typemap for const std::string&
71197
71198   return jresult;
71199 }
71200
71201
71202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71203   void * jresult ;
71204   Dali::BaseHandle arg1 ;
71205   Dali::BaseHandle *argp1 ;
71206   Dali::Toolkit::RadioButton result;
71207
71208   argp1 = (Dali::BaseHandle *)jarg1;
71209   if (!argp1) {
71210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71211     return 0;
71212   }
71213   arg1 = *argp1;
71214   {
71215     try {
71216       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71217     } catch (std::out_of_range& e) {
71218       {
71219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (std::exception& e) {
71222       {
71223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71224       };
71225     } catch (Dali::DaliException e) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71228       };
71229     } catch (...) {
71230       {
71231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71232       };
71233     }
71234   }
71235
71236   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71237   return jresult;
71238 }
71239
71240
71241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71242   int jresult ;
71243   int result;
71244
71245   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71246   jresult = (int)result;
71247   return jresult;
71248 }
71249
71250
71251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71252   int jresult ;
71253   int result;
71254
71255   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71256   jresult = (int)result;
71257   return jresult;
71258 }
71259
71260
71261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71262   int jresult ;
71263   int result;
71264
71265   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71266   jresult = (int)result;
71267   return jresult;
71268 }
71269
71270
71271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71272   int jresult ;
71273   int result;
71274
71275   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71276   jresult = (int)result;
71277   return jresult;
71278 }
71279
71280
71281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71282   int jresult ;
71283   int result;
71284
71285   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71286   jresult = (int)result;
71287   return jresult;
71288 }
71289
71290
71291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71292   int jresult ;
71293   int result;
71294
71295   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71296   jresult = (int)result;
71297   return jresult;
71298 }
71299
71300
71301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71302   void * jresult ;
71303   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71304
71305   {
71306     try {
71307       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71308     } catch (std::out_of_range& e) {
71309       {
71310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71311       };
71312     } catch (std::exception& e) {
71313       {
71314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71315       };
71316     } catch (Dali::DaliException e) {
71317       {
71318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71319       };
71320     } catch (...) {
71321       {
71322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71323       };
71324     }
71325   }
71326
71327   jresult = (void *)result;
71328   return jresult;
71329 }
71330
71331
71332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71333   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71334
71335   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71336   {
71337     try {
71338       delete arg1;
71339     } catch (std::out_of_range& e) {
71340       {
71341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71342       };
71343     } catch (std::exception& e) {
71344       {
71345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71346       };
71347     } catch (Dali::DaliException e) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71350       };
71351     } catch (...) {
71352       {
71353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71354       };
71355     }
71356   }
71357
71358 }
71359
71360
71361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71362   int jresult ;
71363   int result;
71364
71365   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71366   jresult = (int)result;
71367   return jresult;
71368 }
71369
71370
71371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71372   int jresult ;
71373   int result;
71374
71375   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71376   jresult = (int)result;
71377   return jresult;
71378 }
71379
71380
71381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71382   int jresult ;
71383   int result;
71384
71385   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71386   jresult = (int)result;
71387   return jresult;
71388 }
71389
71390
71391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71392   void * jresult ;
71393   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71394
71395   {
71396     try {
71397       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71398     } catch (std::out_of_range& e) {
71399       {
71400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71401       };
71402     } catch (std::exception& e) {
71403       {
71404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71405       };
71406     } catch (Dali::DaliException e) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71409       };
71410     } catch (...) {
71411       {
71412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71413       };
71414     }
71415   }
71416
71417   jresult = (void *)result;
71418   return jresult;
71419 }
71420
71421
71422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71423   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71424
71425   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71426   {
71427     try {
71428       delete arg1;
71429     } catch (std::out_of_range& e) {
71430       {
71431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (std::exception& e) {
71434       {
71435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71436       };
71437     } catch (Dali::DaliException e) {
71438       {
71439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71440       };
71441     } catch (...) {
71442       {
71443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71444       };
71445     }
71446   }
71447
71448 }
71449
71450
71451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71452   void * jresult ;
71453   Dali::Toolkit::FlexContainer *result = 0 ;
71454
71455   {
71456     try {
71457       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71458     } catch (std::out_of_range& e) {
71459       {
71460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71461       };
71462     } catch (std::exception& e) {
71463       {
71464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71465       };
71466     } catch (Dali::DaliException e) {
71467       {
71468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71469       };
71470     } catch (...) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71473       };
71474     }
71475   }
71476
71477   jresult = (void *)result;
71478   return jresult;
71479 }
71480
71481
71482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71483   void * jresult ;
71484   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71485   Dali::Toolkit::FlexContainer *result = 0 ;
71486
71487   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71488   if (!arg1) {
71489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71490     return 0;
71491   }
71492   {
71493     try {
71494       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71495     } catch (std::out_of_range& e) {
71496       {
71497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71498       };
71499     } catch (std::exception& e) {
71500       {
71501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71502       };
71503     } catch (Dali::DaliException e) {
71504       {
71505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71506       };
71507     } catch (...) {
71508       {
71509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71510       };
71511     }
71512   }
71513
71514   jresult = (void *)result;
71515   return jresult;
71516 }
71517
71518
71519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71520   void * jresult ;
71521   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71522   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71523   Dali::Toolkit::FlexContainer *result = 0 ;
71524
71525   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71526   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71527   if (!arg2) {
71528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71529     return 0;
71530   }
71531   {
71532     try {
71533       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71541       };
71542     } catch (Dali::DaliException e) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71545       };
71546     } catch (...) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71549       };
71550     }
71551   }
71552
71553   jresult = (void *)result;
71554   return jresult;
71555 }
71556
71557
71558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71559   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71560
71561   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71562   {
71563     try {
71564       delete arg1;
71565     } catch (std::out_of_range& e) {
71566       {
71567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71568       };
71569     } catch (std::exception& e) {
71570       {
71571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71572       };
71573     } catch (Dali::DaliException e) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71576       };
71577     } catch (...) {
71578       {
71579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71580       };
71581     }
71582   }
71583
71584 }
71585
71586
71587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71588   void * jresult ;
71589   Dali::Toolkit::FlexContainer result;
71590
71591   {
71592     try {
71593       result = Dali::Toolkit::FlexContainer::New();
71594     } catch (std::out_of_range& e) {
71595       {
71596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71597       };
71598     } catch (std::exception& e) {
71599       {
71600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71601       };
71602     } catch (Dali::DaliException e) {
71603       {
71604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71605       };
71606     } catch (...) {
71607       {
71608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71609       };
71610     }
71611   }
71612
71613   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71614   return jresult;
71615 }
71616
71617
71618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71619   void * jresult ;
71620   Dali::BaseHandle arg1 ;
71621   Dali::BaseHandle *argp1 ;
71622   Dali::Toolkit::FlexContainer result;
71623
71624   argp1 = (Dali::BaseHandle *)jarg1;
71625   if (!argp1) {
71626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71627     return 0;
71628   }
71629   arg1 = *argp1;
71630   {
71631     try {
71632       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71633     } catch (std::out_of_range& e) {
71634       {
71635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (std::exception& e) {
71638       {
71639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (Dali::DaliException e) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71648       };
71649     }
71650   }
71651
71652   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71653   return jresult;
71654 }
71655
71656
71657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71658   int jresult ;
71659   int result;
71660
71661   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71662   jresult = (int)result;
71663   return jresult;
71664 }
71665
71666
71667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71668   int jresult ;
71669   int result;
71670
71671   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71672   jresult = (int)result;
71673   return jresult;
71674 }
71675
71676
71677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71678   int jresult ;
71679   int result;
71680
71681   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71682   jresult = (int)result;
71683   return jresult;
71684 }
71685
71686
71687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71688   int jresult ;
71689   int result;
71690
71691   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71692   jresult = (int)result;
71693   return jresult;
71694 }
71695
71696
71697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71698   void * jresult ;
71699   Dali::Toolkit::ImageView::Property *result = 0 ;
71700
71701   {
71702     try {
71703       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71704     } catch (std::out_of_range& e) {
71705       {
71706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (std::exception& e) {
71709       {
71710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71711       };
71712     } catch (Dali::DaliException e) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71715       };
71716     } catch (...) {
71717       {
71718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71719       };
71720     }
71721   }
71722
71723   jresult = (void *)result;
71724   return jresult;
71725 }
71726
71727
71728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71729   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71730
71731   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71732   {
71733     try {
71734       delete arg1;
71735     } catch (std::out_of_range& e) {
71736       {
71737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71738       };
71739     } catch (std::exception& e) {
71740       {
71741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71742       };
71743     } catch (Dali::DaliException e) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71746       };
71747     } catch (...) {
71748       {
71749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71750       };
71751     }
71752   }
71753
71754 }
71755
71756
71757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71758   void * jresult ;
71759   Dali::Toolkit::ImageView *result = 0 ;
71760
71761   {
71762     try {
71763       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71764     } catch (std::out_of_range& e) {
71765       {
71766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71767       };
71768     } catch (std::exception& e) {
71769       {
71770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71771       };
71772     } catch (Dali::DaliException e) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71775       };
71776     } catch (...) {
71777       {
71778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71779       };
71780     }
71781   }
71782
71783   jresult = (void *)result;
71784   return jresult;
71785 }
71786
71787
71788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71789   void * jresult ;
71790   Dali::Toolkit::ImageView result;
71791
71792   {
71793     try {
71794       result = Dali::Toolkit::ImageView::New();
71795     } catch (std::out_of_range& e) {
71796       {
71797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (std::exception& e) {
71800       {
71801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (Dali::DaliException e) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71806       };
71807     } catch (...) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71810       };
71811     }
71812   }
71813
71814   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71815   return jresult;
71816 }
71817
71818
71819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71820   void * jresult ;
71821   Dali::Image arg1 ;
71822   Dali::Image *argp1 ;
71823   Dali::Toolkit::ImageView result;
71824
71825   argp1 = (Dali::Image *)jarg1;
71826   if (!argp1) {
71827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71828     return 0;
71829   }
71830   arg1 = *argp1;
71831   {
71832     try {
71833       result = Dali::Toolkit::ImageView::New(arg1);
71834     } catch (std::out_of_range& e) {
71835       {
71836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71837       };
71838     } catch (std::exception& e) {
71839       {
71840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71841       };
71842     } catch (Dali::DaliException e) {
71843       {
71844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71845       };
71846     } catch (...) {
71847       {
71848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71849       };
71850     }
71851   }
71852
71853   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71854   return jresult;
71855 }
71856
71857
71858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71859   void * jresult ;
71860   std::string *arg1 = 0 ;
71861   Dali::Toolkit::ImageView result;
71862
71863   if (!jarg1) {
71864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71865     return 0;
71866   }
71867   std::string arg1_str(jarg1);
71868   arg1 = &arg1_str;
71869   {
71870     try {
71871       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71872     } catch (std::out_of_range& e) {
71873       {
71874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71875       };
71876     } catch (std::exception& e) {
71877       {
71878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71879       };
71880     } catch (Dali::DaliException e) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71883       };
71884     } catch (...) {
71885       {
71886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71887       };
71888     }
71889   }
71890
71891   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71892
71893   //argout typemap for const std::string&
71894
71895   return jresult;
71896 }
71897
71898
71899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71900   void * jresult ;
71901   std::string *arg1 = 0 ;
71902   Dali::ImageDimensions arg2 ;
71903   Dali::ImageDimensions *argp2 ;
71904   Dali::Toolkit::ImageView result;
71905
71906   if (!jarg1) {
71907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71908     return 0;
71909   }
71910   std::string arg1_str(jarg1);
71911   arg1 = &arg1_str;
71912   argp2 = (Dali::ImageDimensions *)jarg2;
71913   if (!argp2) {
71914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71915     return 0;
71916   }
71917   arg2 = *argp2;
71918   {
71919     try {
71920       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71921     } catch (std::out_of_range& e) {
71922       {
71923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (std::exception& e) {
71926       {
71927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71928       };
71929     } catch (Dali::DaliException e) {
71930       {
71931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71932       };
71933     } catch (...) {
71934       {
71935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71936       };
71937     }
71938   }
71939
71940   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71941
71942   //argout typemap for const std::string&
71943
71944   return jresult;
71945 }
71946
71947
71948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71949   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71950
71951   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71952   {
71953     try {
71954       delete arg1;
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71962       };
71963     } catch (Dali::DaliException e) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71966       };
71967     } catch (...) {
71968       {
71969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71970       };
71971     }
71972   }
71973
71974 }
71975
71976
71977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71978   void * jresult ;
71979   Dali::Toolkit::ImageView *arg1 = 0 ;
71980   Dali::Toolkit::ImageView *result = 0 ;
71981
71982   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71983   if (!arg1) {
71984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71985     return 0;
71986   }
71987   {
71988     try {
71989       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71990     } catch (std::out_of_range& e) {
71991       {
71992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71993       };
71994     } catch (std::exception& e) {
71995       {
71996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71997       };
71998     } catch (Dali::DaliException e) {
71999       {
72000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72001       };
72002     } catch (...) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72005       };
72006     }
72007   }
72008
72009   jresult = (void *)result;
72010   return jresult;
72011 }
72012
72013
72014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72015   void * jresult ;
72016   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72017   Dali::Toolkit::ImageView *arg2 = 0 ;
72018   Dali::Toolkit::ImageView *result = 0 ;
72019
72020   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72021   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72022   if (!arg2) {
72023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72024     return 0;
72025   }
72026   {
72027     try {
72028       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72029     } catch (std::out_of_range& e) {
72030       {
72031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72032       };
72033     } catch (std::exception& e) {
72034       {
72035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72036       };
72037     } catch (Dali::DaliException e) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72040       };
72041     } catch (...) {
72042       {
72043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72044       };
72045     }
72046   }
72047
72048   jresult = (void *)result;
72049   return jresult;
72050 }
72051
72052
72053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72054   void * jresult ;
72055   Dali::BaseHandle arg1 ;
72056   Dali::BaseHandle *argp1 ;
72057   Dali::Toolkit::ImageView result;
72058
72059   argp1 = (Dali::BaseHandle *)jarg1;
72060   if (!argp1) {
72061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72062     return 0;
72063   }
72064   arg1 = *argp1;
72065   {
72066     try {
72067       result = Dali::Toolkit::ImageView::DownCast(arg1);
72068     } catch (std::out_of_range& e) {
72069       {
72070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72071       };
72072     } catch (std::exception& e) {
72073       {
72074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72075       };
72076     } catch (Dali::DaliException e) {
72077       {
72078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72079       };
72080     } catch (...) {
72081       {
72082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72083       };
72084     }
72085   }
72086
72087   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72088   return jresult;
72089 }
72090
72091
72092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72093   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72094   Dali::Image arg2 ;
72095   Dali::Image *argp2 ;
72096
72097   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72098   argp2 = (Dali::Image *)jarg2;
72099   if (!argp2) {
72100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72101     return ;
72102   }
72103   arg2 = *argp2;
72104   {
72105     try {
72106       (arg1)->SetImage(arg2);
72107     } catch (std::out_of_range& e) {
72108       {
72109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72110       };
72111     } catch (std::exception& e) {
72112       {
72113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72114       };
72115     } catch (Dali::DaliException e) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72118       };
72119     } catch (...) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72122       };
72123     }
72124   }
72125
72126 }
72127
72128
72129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72130   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72131   std::string *arg2 = 0 ;
72132
72133   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72134   if (!jarg2) {
72135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72136     return ;
72137   }
72138   std::string arg2_str(jarg2);
72139   arg2 = &arg2_str;
72140   {
72141     try {
72142       (arg1)->SetImage((std::string const &)*arg2);
72143     } catch (std::out_of_range& e) {
72144       {
72145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72146       };
72147     } catch (std::exception& e) {
72148       {
72149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72150       };
72151     } catch (Dali::DaliException e) {
72152       {
72153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72154       };
72155     } catch (...) {
72156       {
72157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72158       };
72159     }
72160   }
72161
72162
72163   //argout typemap for const std::string&
72164
72165 }
72166
72167
72168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72169   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72170   std::string *arg2 = 0 ;
72171   Dali::ImageDimensions arg3 ;
72172   Dali::ImageDimensions *argp3 ;
72173
72174   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72175   if (!jarg2) {
72176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72177     return ;
72178   }
72179   std::string arg2_str(jarg2);
72180   arg2 = &arg2_str;
72181   argp3 = (Dali::ImageDimensions *)jarg3;
72182   if (!argp3) {
72183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72184     return ;
72185   }
72186   arg3 = *argp3;
72187   {
72188     try {
72189       (arg1)->SetImage((std::string const &)*arg2,arg3);
72190     } catch (std::out_of_range& e) {
72191       {
72192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72193       };
72194     } catch (std::exception& e) {
72195       {
72196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72197       };
72198     } catch (Dali::DaliException e) {
72199       {
72200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72201       };
72202     } catch (...) {
72203       {
72204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72205       };
72206     }
72207   }
72208
72209
72210   //argout typemap for const std::string&
72211
72212 }
72213
72214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72215   void * jresult ;
72216   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72217   Dali::Image result;
72218
72219   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72220   {
72221     try {
72222       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72223     } catch (std::out_of_range& e) {
72224       {
72225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (std::exception& e) {
72228       {
72229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72230       };
72231     } catch (Dali::DaliException e) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72234       };
72235     } catch (...) {
72236       {
72237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72238       };
72239     }
72240   }
72241
72242   jresult = new Dali::Image((const Dali::Image &)result);
72243   return jresult;
72244 }
72245
72246
72247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72248   int jresult ;
72249   int result;
72250
72251   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72252   jresult = (int)result;
72253   return jresult;
72254 }
72255
72256
72257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72258   int jresult ;
72259   int result;
72260
72261   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72262   jresult = (int)result;
72263   return jresult;
72264 }
72265
72266
72267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72268   int jresult ;
72269   int result;
72270
72271   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72272   jresult = (int)result;
72273   return jresult;
72274 }
72275
72276
72277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72278   int jresult ;
72279   int result;
72280
72281   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72282   jresult = (int)result;
72283   return jresult;
72284 }
72285
72286
72287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72288   int jresult ;
72289   int result;
72290
72291   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72292   jresult = (int)result;
72293   return jresult;
72294 }
72295
72296
72297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72298   int jresult ;
72299   int result;
72300
72301   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72302   jresult = (int)result;
72303   return jresult;
72304 }
72305
72306
72307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72308   int jresult ;
72309   int result;
72310
72311   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72312   jresult = (int)result;
72313   return jresult;
72314 }
72315
72316
72317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72318   int jresult ;
72319   int result;
72320
72321   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72322   jresult = (int)result;
72323   return jresult;
72324 }
72325
72326
72327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72328   void * jresult ;
72329   Dali::Toolkit::Model3dView::Property *result = 0 ;
72330
72331   {
72332     try {
72333       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72334     } catch (std::out_of_range& e) {
72335       {
72336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (std::exception& e) {
72339       {
72340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (Dali::DaliException e) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72345       };
72346     } catch (...) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72349       };
72350     }
72351   }
72352
72353   jresult = (void *)result;
72354   return jresult;
72355 }
72356
72357
72358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72359   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72360
72361   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72362   {
72363     try {
72364       delete arg1;
72365     } catch (std::out_of_range& e) {
72366       {
72367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72368       };
72369     } catch (std::exception& e) {
72370       {
72371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72372       };
72373     } catch (Dali::DaliException e) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72376       };
72377     } catch (...) {
72378       {
72379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72380       };
72381     }
72382   }
72383
72384 }
72385
72386
72387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72388   void * jresult ;
72389   Dali::Toolkit::Model3dView result;
72390
72391   {
72392     try {
72393       result = Dali::Toolkit::Model3dView::New();
72394     } catch (std::out_of_range& e) {
72395       {
72396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (std::exception& e) {
72399       {
72400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72401       };
72402     } catch (Dali::DaliException e) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72405       };
72406     } catch (...) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72409       };
72410     }
72411   }
72412
72413   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72414   return jresult;
72415 }
72416
72417
72418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72419   void * jresult ;
72420   std::string *arg1 = 0 ;
72421   std::string *arg2 = 0 ;
72422   std::string *arg3 = 0 ;
72423   Dali::Toolkit::Model3dView result;
72424
72425   if (!jarg1) {
72426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72427     return 0;
72428   }
72429   std::string arg1_str(jarg1);
72430   arg1 = &arg1_str;
72431   if (!jarg2) {
72432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72433     return 0;
72434   }
72435   std::string arg2_str(jarg2);
72436   arg2 = &arg2_str;
72437   if (!jarg3) {
72438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72439     return 0;
72440   }
72441   std::string arg3_str(jarg3);
72442   arg3 = &arg3_str;
72443   {
72444     try {
72445       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72446     } catch (std::out_of_range& e) {
72447       {
72448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72449       };
72450     } catch (std::exception& e) {
72451       {
72452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72453       };
72454     } catch (Dali::DaliException e) {
72455       {
72456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72457       };
72458     } catch (...) {
72459       {
72460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72461       };
72462     }
72463   }
72464
72465   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72466
72467   //argout typemap for const std::string&
72468
72469
72470   //argout typemap for const std::string&
72471
72472
72473   //argout typemap for const std::string&
72474
72475   return jresult;
72476 }
72477
72478
72479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72480   void * jresult ;
72481   Dali::Toolkit::Model3dView *result = 0 ;
72482
72483   {
72484     try {
72485       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72486     } catch (std::out_of_range& e) {
72487       {
72488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (std::exception& e) {
72491       {
72492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72493       };
72494     } catch (Dali::DaliException e) {
72495       {
72496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72497       };
72498     } catch (...) {
72499       {
72500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72501       };
72502     }
72503   }
72504
72505   jresult = (void *)result;
72506   return jresult;
72507 }
72508
72509
72510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72511   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72512
72513   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72514   {
72515     try {
72516       delete arg1;
72517     } catch (std::out_of_range& e) {
72518       {
72519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72520       };
72521     } catch (std::exception& e) {
72522       {
72523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72524       };
72525     } catch (Dali::DaliException e) {
72526       {
72527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72528       };
72529     } catch (...) {
72530       {
72531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72532       };
72533     }
72534   }
72535
72536 }
72537
72538
72539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72540   void * jresult ;
72541   Dali::Toolkit::Model3dView *arg1 = 0 ;
72542   Dali::Toolkit::Model3dView *result = 0 ;
72543
72544   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72545   if (!arg1) {
72546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72547     return 0;
72548   }
72549   {
72550     try {
72551       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72552     } catch (std::out_of_range& e) {
72553       {
72554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72555       };
72556     } catch (std::exception& e) {
72557       {
72558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72559       };
72560     } catch (Dali::DaliException e) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72563       };
72564     } catch (...) {
72565       {
72566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72567       };
72568     }
72569   }
72570
72571   jresult = (void *)result;
72572   return jresult;
72573 }
72574
72575
72576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72577   void * jresult ;
72578   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72579   Dali::Toolkit::Model3dView *arg2 = 0 ;
72580   Dali::Toolkit::Model3dView *result = 0 ;
72581
72582   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72583   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72584   if (!arg2) {
72585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72586     return 0;
72587   }
72588   {
72589     try {
72590       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72591     } catch (std::out_of_range& e) {
72592       {
72593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (std::exception& e) {
72596       {
72597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (Dali::DaliException e) {
72600       {
72601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72602       };
72603     } catch (...) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72606       };
72607     }
72608   }
72609
72610   jresult = (void *)result;
72611   return jresult;
72612 }
72613
72614
72615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72616   void * jresult ;
72617   Dali::BaseHandle arg1 ;
72618   Dali::BaseHandle *argp1 ;
72619   Dali::Toolkit::Model3dView result;
72620
72621   argp1 = (Dali::BaseHandle *)jarg1;
72622   if (!argp1) {
72623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72624     return 0;
72625   }
72626   arg1 = *argp1;
72627   {
72628     try {
72629       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72630     } catch (std::out_of_range& e) {
72631       {
72632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72633       };
72634     } catch (std::exception& e) {
72635       {
72636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72637       };
72638     } catch (Dali::DaliException e) {
72639       {
72640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72641       };
72642     } catch (...) {
72643       {
72644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72645       };
72646     }
72647   }
72648
72649   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72650   return jresult;
72651 }
72652
72653
72654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72655   int jresult ;
72656   int result;
72657
72658   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72659   jresult = (int)result;
72660   return jresult;
72661 }
72662
72663
72664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72665   int jresult ;
72666   int result;
72667
72668   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72669   jresult = (int)result;
72670   return jresult;
72671 }
72672
72673
72674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72675   int jresult ;
72676   int result;
72677
72678   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72679   jresult = (int)result;
72680   return jresult;
72681 }
72682
72683
72684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72685   int jresult ;
72686   int result;
72687
72688   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72689   jresult = (int)result;
72690   return jresult;
72691 }
72692
72693
72694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72695   int jresult ;
72696   int result;
72697
72698   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72699   jresult = (int)result;
72700   return jresult;
72701 }
72702
72703
72704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72705   int jresult ;
72706   int result;
72707
72708   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72709   jresult = (int)result;
72710   return jresult;
72711 }
72712
72713
72714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72715   int jresult ;
72716   int result;
72717
72718   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72719   jresult = (int)result;
72720   return jresult;
72721 }
72722
72723
72724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72725   int jresult ;
72726   int result;
72727
72728   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72729   jresult = (int)result;
72730   return jresult;
72731 }
72732
72733
72734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72735   int jresult ;
72736   int result;
72737
72738   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72739   jresult = (int)result;
72740   return jresult;
72741 }
72742
72743
72744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72745   void * jresult ;
72746   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72747
72748   {
72749     try {
72750       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72751     } catch (std::out_of_range& e) {
72752       {
72753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (std::exception& e) {
72756       {
72757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72758       };
72759     } catch (Dali::DaliException e) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72762       };
72763     } catch (...) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72766       };
72767     }
72768   }
72769
72770   jresult = (void *)result;
72771   return jresult;
72772 }
72773
72774
72775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72776   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72777
72778   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72779   {
72780     try {
72781       delete arg1;
72782     } catch (std::out_of_range& e) {
72783       {
72784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72785       };
72786     } catch (std::exception& e) {
72787       {
72788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72789       };
72790     } catch (Dali::DaliException e) {
72791       {
72792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72793       };
72794     } catch (...) {
72795       {
72796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72797       };
72798     }
72799   }
72800
72801 }
72802
72803
72804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72805   void * jresult ;
72806   Dali::Toolkit::ScrollBar *result = 0 ;
72807
72808   {
72809     try {
72810       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72811     } catch (std::out_of_range& e) {
72812       {
72813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (std::exception& e) {
72816       {
72817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72818       };
72819     } catch (Dali::DaliException e) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72822       };
72823     } catch (...) {
72824       {
72825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72826       };
72827     }
72828   }
72829
72830   jresult = (void *)result;
72831   return jresult;
72832 }
72833
72834
72835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72836   void * jresult ;
72837   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72838   Dali::Toolkit::ScrollBar *result = 0 ;
72839
72840   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72841   if (!arg1) {
72842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72843     return 0;
72844   }
72845   {
72846     try {
72847       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72848     } catch (std::out_of_range& e) {
72849       {
72850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72851       };
72852     } catch (std::exception& e) {
72853       {
72854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72855       };
72856     } catch (Dali::DaliException e) {
72857       {
72858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72859       };
72860     } catch (...) {
72861       {
72862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72863       };
72864     }
72865   }
72866
72867   jresult = (void *)result;
72868   return jresult;
72869 }
72870
72871
72872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72873   void * jresult ;
72874   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72875   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72876   Dali::Toolkit::ScrollBar *result = 0 ;
72877
72878   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72879   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72880   if (!arg2) {
72881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72882     return 0;
72883   }
72884   {
72885     try {
72886       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72887     } catch (std::out_of_range& e) {
72888       {
72889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (std::exception& e) {
72892       {
72893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (Dali::DaliException e) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72898       };
72899     } catch (...) {
72900       {
72901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72902       };
72903     }
72904   }
72905
72906   jresult = (void *)result;
72907   return jresult;
72908 }
72909
72910
72911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72912   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72913
72914   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72915   {
72916     try {
72917       delete arg1;
72918     } catch (std::out_of_range& e) {
72919       {
72920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72921       };
72922     } catch (std::exception& e) {
72923       {
72924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72925       };
72926     } catch (Dali::DaliException e) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72929       };
72930     } catch (...) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72933       };
72934     }
72935   }
72936
72937 }
72938
72939
72940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72941   void * jresult ;
72942   Dali::Toolkit::ScrollBar::Direction arg1 ;
72943   Dali::Toolkit::ScrollBar result;
72944
72945   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72946   {
72947     try {
72948       result = Dali::Toolkit::ScrollBar::New(arg1);
72949     } catch (std::out_of_range& e) {
72950       {
72951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (std::exception& e) {
72954       {
72955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72956       };
72957     } catch (Dali::DaliException e) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72960       };
72961     } catch (...) {
72962       {
72963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72964       };
72965     }
72966   }
72967
72968   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72969   return jresult;
72970 }
72971
72972
72973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72974   void * jresult ;
72975   Dali::Toolkit::ScrollBar result;
72976
72977   {
72978     try {
72979       result = Dali::Toolkit::ScrollBar::New();
72980     } catch (std::out_of_range& e) {
72981       {
72982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72983       };
72984     } catch (std::exception& e) {
72985       {
72986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72987       };
72988     } catch (Dali::DaliException e) {
72989       {
72990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72991       };
72992     } catch (...) {
72993       {
72994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72995       };
72996     }
72997   }
72998
72999   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73000   return jresult;
73001 }
73002
73003
73004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73005   void * jresult ;
73006   Dali::BaseHandle arg1 ;
73007   Dali::BaseHandle *argp1 ;
73008   Dali::Toolkit::ScrollBar result;
73009
73010   argp1 = (Dali::BaseHandle *)jarg1;
73011   if (!argp1) {
73012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73013     return 0;
73014   }
73015   arg1 = *argp1;
73016   {
73017     try {
73018       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73019     } catch (std::out_of_range& e) {
73020       {
73021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (std::exception& e) {
73024       {
73025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (Dali::DaliException e) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73030       };
73031     } catch (...) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73034       };
73035     }
73036   }
73037
73038   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73039   return jresult;
73040 }
73041
73042
73043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73044   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73045   Dali::Handle arg2 ;
73046   Dali::Property::Index arg3 ;
73047   Dali::Property::Index arg4 ;
73048   Dali::Property::Index arg5 ;
73049   Dali::Property::Index arg6 ;
73050   Dali::Handle *argp2 ;
73051
73052   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73053   argp2 = (Dali::Handle *)jarg2;
73054   if (!argp2) {
73055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73056     return ;
73057   }
73058   arg2 = *argp2;
73059   arg3 = (Dali::Property::Index)jarg3;
73060   arg4 = (Dali::Property::Index)jarg4;
73061   arg5 = (Dali::Property::Index)jarg5;
73062   arg6 = (Dali::Property::Index)jarg6;
73063   {
73064     try {
73065       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73073       };
73074     } catch (Dali::DaliException e) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73081       };
73082     }
73083   }
73084
73085 }
73086
73087
73088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73089   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73090   Dali::Actor arg2 ;
73091   Dali::Actor *argp2 ;
73092
73093   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73094   argp2 = (Dali::Actor *)jarg2;
73095   if (!argp2) {
73096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73097     return ;
73098   }
73099   arg2 = *argp2;
73100   {
73101     try {
73102       (arg1)->SetScrollIndicator(arg2);
73103     } catch (std::out_of_range& e) {
73104       {
73105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73106       };
73107     } catch (std::exception& e) {
73108       {
73109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73110       };
73111     } catch (Dali::DaliException e) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73114       };
73115     } catch (...) {
73116       {
73117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73118       };
73119     }
73120   }
73121
73122 }
73123
73124
73125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73126   void * jresult ;
73127   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73128   Dali::Actor result;
73129
73130   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73131   {
73132     try {
73133       result = (arg1)->GetScrollIndicator();
73134     } catch (std::out_of_range& e) {
73135       {
73136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73137       };
73138     } catch (std::exception& e) {
73139       {
73140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73141       };
73142     } catch (Dali::DaliException e) {
73143       {
73144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73145       };
73146     } catch (...) {
73147       {
73148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73149       };
73150     }
73151   }
73152
73153   jresult = new Dali::Actor((const Dali::Actor &)result);
73154   return jresult;
73155 }
73156
73157
73158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73159   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73160   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73161
73162   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73163   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73164   if (!arg2) {
73165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73166     return ;
73167   }
73168   {
73169     try {
73170       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73171     } catch (std::out_of_range& e) {
73172       {
73173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73174       };
73175     } catch (std::exception& e) {
73176       {
73177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73178       };
73179     } catch (Dali::DaliException e) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73182       };
73183     } catch (...) {
73184       {
73185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73186       };
73187     }
73188   }
73189
73190 }
73191
73192
73193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73194   void * jresult ;
73195   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73196
73197   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73198   {
73199     try {
73200       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()));
73201     } catch (std::out_of_range& e) {
73202       {
73203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (std::exception& e) {
73206       {
73207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73208       };
73209     } catch (...) {
73210       {
73211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73212       };
73213     }
73214   }
73215   return jresult;
73216 }
73217
73218
73219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73220   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73221   Dali::Toolkit::ScrollBar::Direction arg2 ;
73222
73223   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73224   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73225   {
73226     try {
73227       (arg1)->SetScrollDirection(arg2);
73228     } catch (std::out_of_range& e) {
73229       {
73230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73231       };
73232     } catch (std::exception& e) {
73233       {
73234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73235       };
73236     } catch (Dali::DaliException e) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73239       };
73240     } catch (...) {
73241       {
73242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73243       };
73244     }
73245   }
73246
73247 }
73248
73249
73250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73251   int jresult ;
73252   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73253   Dali::Toolkit::ScrollBar::Direction result;
73254
73255   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73256   {
73257     try {
73258       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73259     } catch (std::out_of_range& e) {
73260       {
73261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (std::exception& e) {
73264       {
73265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (Dali::DaliException e) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73270       };
73271     } catch (...) {
73272       {
73273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73274       };
73275     }
73276   }
73277
73278   jresult = (int)result;
73279   return jresult;
73280 }
73281
73282
73283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73284   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73285   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73286
73287   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73288   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73289   {
73290     try {
73291       (arg1)->SetIndicatorHeightPolicy(arg2);
73292     } catch (std::out_of_range& e) {
73293       {
73294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73295       };
73296     } catch (std::exception& e) {
73297       {
73298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73299       };
73300     } catch (Dali::DaliException e) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73303       };
73304     } catch (...) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73307       };
73308     }
73309   }
73310
73311 }
73312
73313
73314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73315   int jresult ;
73316   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73317   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73318
73319   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73320   {
73321     try {
73322       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73323     } catch (std::out_of_range& e) {
73324       {
73325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (std::exception& e) {
73328       {
73329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73330       };
73331     } catch (Dali::DaliException e) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73334       };
73335     } catch (...) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73338       };
73339     }
73340   }
73341
73342   jresult = (int)result;
73343   return jresult;
73344 }
73345
73346
73347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73348   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73349   float arg2 ;
73350
73351   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73352   arg2 = (float)jarg2;
73353   {
73354     try {
73355       (arg1)->SetIndicatorFixedHeight(arg2);
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73363       };
73364     } catch (Dali::DaliException e) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73367       };
73368     } catch (...) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73371       };
73372     }
73373   }
73374
73375 }
73376
73377
73378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73379   float jresult ;
73380   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73381   float result;
73382
73383   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73384   {
73385     try {
73386       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73387     } catch (std::out_of_range& e) {
73388       {
73389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73390       };
73391     } catch (std::exception& e) {
73392       {
73393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73394       };
73395     } catch (Dali::DaliException e) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73398       };
73399     } catch (...) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73402       };
73403     }
73404   }
73405
73406   jresult = result;
73407   return jresult;
73408 }
73409
73410
73411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73412   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73413   float arg2 ;
73414
73415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73416   arg2 = (float)jarg2;
73417   {
73418     try {
73419       (arg1)->SetIndicatorShowDuration(arg2);
73420     } catch (std::out_of_range& e) {
73421       {
73422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73423       };
73424     } catch (std::exception& e) {
73425       {
73426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73427       };
73428     } catch (Dali::DaliException e) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73431       };
73432     } catch (...) {
73433       {
73434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73435       };
73436     }
73437   }
73438
73439 }
73440
73441
73442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73443   float jresult ;
73444   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73445   float result;
73446
73447   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73448   {
73449     try {
73450       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73451     } catch (std::out_of_range& e) {
73452       {
73453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73454       };
73455     } catch (std::exception& e) {
73456       {
73457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73458       };
73459     } catch (Dali::DaliException e) {
73460       {
73461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73462       };
73463     } catch (...) {
73464       {
73465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73466       };
73467     }
73468   }
73469
73470   jresult = result;
73471   return jresult;
73472 }
73473
73474
73475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73476   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73477   float arg2 ;
73478
73479   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73480   arg2 = (float)jarg2;
73481   {
73482     try {
73483       (arg1)->SetIndicatorHideDuration(arg2);
73484     } catch (std::out_of_range& e) {
73485       {
73486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73487       };
73488     } catch (std::exception& e) {
73489       {
73490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73491       };
73492     } catch (Dali::DaliException e) {
73493       {
73494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73495       };
73496     } catch (...) {
73497       {
73498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73499       };
73500     }
73501   }
73502
73503 }
73504
73505
73506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73507   float jresult ;
73508   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73509   float result;
73510
73511   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73512   {
73513     try {
73514       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73515     } catch (std::out_of_range& e) {
73516       {
73517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (std::exception& e) {
73520       {
73521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73522       };
73523     } catch (Dali::DaliException e) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73526       };
73527     } catch (...) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73530       };
73531     }
73532   }
73533
73534   jresult = result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73540   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73541
73542   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73543   {
73544     try {
73545       (arg1)->ShowIndicator();
73546     } catch (std::out_of_range& e) {
73547       {
73548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73549       };
73550     } catch (std::exception& e) {
73551       {
73552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73553       };
73554     } catch (Dali::DaliException e) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73557       };
73558     } catch (...) {
73559       {
73560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73561       };
73562     }
73563   }
73564
73565 }
73566
73567
73568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73569   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73570
73571   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73572   {
73573     try {
73574       (arg1)->HideIndicator();
73575     } catch (std::out_of_range& e) {
73576       {
73577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73578       };
73579     } catch (std::exception& e) {
73580       {
73581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73582       };
73583     } catch (Dali::DaliException e) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73586       };
73587     } catch (...) {
73588       {
73589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73590       };
73591     }
73592   }
73593
73594 }
73595
73596
73597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73598   void * jresult ;
73599   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73600   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73601
73602   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73603   {
73604     try {
73605       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73606     } catch (std::out_of_range& e) {
73607       {
73608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73609       };
73610     } catch (std::exception& e) {
73611       {
73612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73613       };
73614     } catch (Dali::DaliException e) {
73615       {
73616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73617       };
73618     } catch (...) {
73619       {
73620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73621       };
73622     }
73623   }
73624
73625   jresult = (void *)result;
73626   return jresult;
73627 }
73628
73629
73630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73631   void * jresult ;
73632   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73633   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73634
73635   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73636   {
73637     try {
73638       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73639     } catch (std::out_of_range& e) {
73640       {
73641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73642       };
73643     } catch (std::exception& e) {
73644       {
73645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73646       };
73647     } catch (Dali::DaliException e) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73650       };
73651     } catch (...) {
73652       {
73653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73654       };
73655     }
73656   }
73657
73658   jresult = (void *)result;
73659   return jresult;
73660 }
73661
73662
73663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73664   int jresult ;
73665   int result;
73666
73667   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73668   jresult = (int)result;
73669   return jresult;
73670 }
73671
73672
73673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73674   int jresult ;
73675   int result;
73676
73677   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73678   jresult = (int)result;
73679   return jresult;
73680 }
73681
73682
73683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73684   int jresult ;
73685   int result;
73686
73687   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73688   jresult = (int)result;
73689   return jresult;
73690 }
73691
73692
73693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73694   int jresult ;
73695   int result;
73696
73697   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73698   jresult = (int)result;
73699   return jresult;
73700 }
73701
73702
73703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73704   int jresult ;
73705   int result;
73706
73707   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73708   jresult = (int)result;
73709   return jresult;
73710 }
73711
73712
73713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73714   int jresult ;
73715   int result;
73716
73717   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73718   jresult = (int)result;
73719   return jresult;
73720 }
73721
73722
73723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73724   int jresult ;
73725   int result;
73726
73727   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73728   jresult = (int)result;
73729   return jresult;
73730 }
73731
73732
73733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73734   int jresult ;
73735   int result;
73736
73737   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73738   jresult = (int)result;
73739   return jresult;
73740 }
73741
73742
73743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73744   int jresult ;
73745   int result;
73746
73747   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73748   jresult = (int)result;
73749   return jresult;
73750 }
73751
73752
73753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73754   int jresult ;
73755   int result;
73756
73757   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73758   jresult = (int)result;
73759   return jresult;
73760 }
73761
73762
73763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73764   int jresult ;
73765   int result;
73766
73767   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73768   jresult = (int)result;
73769   return jresult;
73770 }
73771
73772
73773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73774   int jresult ;
73775   int result;
73776
73777   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73778   jresult = (int)result;
73779   return jresult;
73780 }
73781
73782
73783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73784   int jresult ;
73785   int result;
73786
73787   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73788   jresult = (int)result;
73789   return jresult;
73790 }
73791
73792
73793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73794   int jresult ;
73795   int result;
73796
73797   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73798   jresult = (int)result;
73799   return jresult;
73800 }
73801
73802
73803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73804   void * jresult ;
73805   Dali::Toolkit::Scrollable::Property *result = 0 ;
73806
73807   {
73808     try {
73809       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73810     } catch (std::out_of_range& e) {
73811       {
73812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73813       };
73814     } catch (std::exception& e) {
73815       {
73816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73817       };
73818     } catch (Dali::DaliException e) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73821       };
73822     } catch (...) {
73823       {
73824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73825       };
73826     }
73827   }
73828
73829   jresult = (void *)result;
73830   return jresult;
73831 }
73832
73833
73834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73835   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73836
73837   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73838   {
73839     try {
73840       delete arg1;
73841     } catch (std::out_of_range& e) {
73842       {
73843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73844       };
73845     } catch (std::exception& e) {
73846       {
73847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73848       };
73849     } catch (Dali::DaliException e) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73852       };
73853     } catch (...) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73856       };
73857     }
73858   }
73859
73860 }
73861
73862
73863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73864   void * jresult ;
73865   Dali::Toolkit::Scrollable *result = 0 ;
73866
73867   {
73868     try {
73869       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73870     } catch (std::out_of_range& e) {
73871       {
73872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73873       };
73874     } catch (std::exception& e) {
73875       {
73876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73877       };
73878     } catch (Dali::DaliException e) {
73879       {
73880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73881       };
73882     } catch (...) {
73883       {
73884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73885       };
73886     }
73887   }
73888
73889   jresult = (void *)result;
73890   return jresult;
73891 }
73892
73893
73894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73895   void * jresult ;
73896   Dali::Toolkit::Scrollable *arg1 = 0 ;
73897   Dali::Toolkit::Scrollable *result = 0 ;
73898
73899   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73900   if (!arg1) {
73901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73902     return 0;
73903   }
73904   {
73905     try {
73906       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73907     } catch (std::out_of_range& e) {
73908       {
73909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73910       };
73911     } catch (std::exception& e) {
73912       {
73913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73914       };
73915     } catch (Dali::DaliException e) {
73916       {
73917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73918       };
73919     } catch (...) {
73920       {
73921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73922       };
73923     }
73924   }
73925
73926   jresult = (void *)result;
73927   return jresult;
73928 }
73929
73930
73931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73932   void * jresult ;
73933   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73934   Dali::Toolkit::Scrollable *arg2 = 0 ;
73935   Dali::Toolkit::Scrollable *result = 0 ;
73936
73937   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73938   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73939   if (!arg2) {
73940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73941     return 0;
73942   }
73943   {
73944     try {
73945       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73946     } catch (std::out_of_range& e) {
73947       {
73948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73949       };
73950     } catch (std::exception& e) {
73951       {
73952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73953       };
73954     } catch (Dali::DaliException e) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73957       };
73958     } catch (...) {
73959       {
73960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73961       };
73962     }
73963   }
73964
73965   jresult = (void *)result;
73966   return jresult;
73967 }
73968
73969
73970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73971   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73972
73973   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73974   {
73975     try {
73976       delete arg1;
73977     } catch (std::out_of_range& e) {
73978       {
73979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73980       };
73981     } catch (std::exception& e) {
73982       {
73983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73984       };
73985     } catch (Dali::DaliException e) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73988       };
73989     } catch (...) {
73990       {
73991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73992       };
73993     }
73994   }
73995
73996 }
73997
73998
73999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74000   void * jresult ;
74001   Dali::BaseHandle arg1 ;
74002   Dali::BaseHandle *argp1 ;
74003   Dali::Toolkit::Scrollable result;
74004
74005   argp1 = (Dali::BaseHandle *)jarg1;
74006   if (!argp1) {
74007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74008     return 0;
74009   }
74010   arg1 = *argp1;
74011   {
74012     try {
74013       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74014     } catch (std::out_of_range& e) {
74015       {
74016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (std::exception& e) {
74019       {
74020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74021       };
74022     } catch (Dali::DaliException e) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74025       };
74026     } catch (...) {
74027       {
74028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74029       };
74030     }
74031   }
74032
74033   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74034   return jresult;
74035 }
74036
74037
74038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74039   unsigned int jresult ;
74040   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74041   bool result;
74042
74043   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74044   {
74045     try {
74046       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74047     } catch (std::out_of_range& e) {
74048       {
74049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74050       };
74051     } catch (std::exception& e) {
74052       {
74053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74054       };
74055     } catch (Dali::DaliException e) {
74056       {
74057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74058       };
74059     } catch (...) {
74060       {
74061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74062       };
74063     }
74064   }
74065
74066   jresult = result;
74067   return jresult;
74068 }
74069
74070
74071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74072   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74073   bool arg2 ;
74074
74075   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74076   arg2 = jarg2 ? true : false;
74077   {
74078     try {
74079       (arg1)->SetOvershootEnabled(arg2);
74080     } catch (std::out_of_range& e) {
74081       {
74082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (std::exception& e) {
74085       {
74086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74087       };
74088     } catch (Dali::DaliException e) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74091       };
74092     } catch (...) {
74093       {
74094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74095       };
74096     }
74097   }
74098
74099 }
74100
74101
74102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74103   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74104   Dali::Vector4 *arg2 = 0 ;
74105
74106   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74107   arg2 = (Dali::Vector4 *)jarg2;
74108   if (!arg2) {
74109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74110     return ;
74111   }
74112   {
74113     try {
74114       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74115     } catch (std::out_of_range& e) {
74116       {
74117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74118       };
74119     } catch (std::exception& e) {
74120       {
74121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74122       };
74123     } catch (Dali::DaliException e) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74126       };
74127     } catch (...) {
74128       {
74129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74130       };
74131     }
74132   }
74133
74134 }
74135
74136
74137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74138   void * jresult ;
74139   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74140   Dali::Vector4 result;
74141
74142   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74143   {
74144     try {
74145       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74146     } catch (std::out_of_range& e) {
74147       {
74148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74149       };
74150     } catch (std::exception& e) {
74151       {
74152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74153       };
74154     } catch (Dali::DaliException e) {
74155       {
74156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74157       };
74158     } catch (...) {
74159       {
74160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74161       };
74162     }
74163   }
74164
74165   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74166   return jresult;
74167 }
74168
74169
74170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74171   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74172   float arg2 ;
74173
74174   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74175   arg2 = (float)jarg2;
74176   {
74177     try {
74178       (arg1)->SetOvershootAnimationSpeed(arg2);
74179     } catch (std::out_of_range& e) {
74180       {
74181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (std::exception& e) {
74184       {
74185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74186       };
74187     } catch (Dali::DaliException e) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74190       };
74191     } catch (...) {
74192       {
74193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74194       };
74195     }
74196   }
74197
74198 }
74199
74200
74201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74202   float jresult ;
74203   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74204   float result;
74205
74206   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74207   {
74208     try {
74209       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74210     } catch (std::out_of_range& e) {
74211       {
74212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (std::exception& e) {
74215       {
74216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74217       };
74218     } catch (Dali::DaliException e) {
74219       {
74220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74221       };
74222     } catch (...) {
74223       {
74224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74225       };
74226     }
74227   }
74228
74229   jresult = result;
74230   return jresult;
74231 }
74232
74233
74234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74235   void * jresult ;
74236   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74237   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74238
74239   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74240   {
74241     try {
74242       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74243     } catch (std::out_of_range& e) {
74244       {
74245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (std::exception& e) {
74248       {
74249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74250       };
74251     } catch (Dali::DaliException e) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74254       };
74255     } catch (...) {
74256       {
74257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74258       };
74259     }
74260   }
74261
74262   jresult = (void *)result;
74263   return jresult;
74264 }
74265
74266
74267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74268   void * jresult ;
74269   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74270   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74271
74272   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74273   {
74274     try {
74275       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (Dali::DaliException e) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74287       };
74288     } catch (...) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74291       };
74292     }
74293   }
74294
74295   jresult = (void *)result;
74296   return jresult;
74297 }
74298
74299
74300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74301   void * jresult ;
74302   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74303   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74304
74305   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74306   {
74307     try {
74308       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74309     } catch (std::out_of_range& e) {
74310       {
74311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (std::exception& e) {
74314       {
74315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74316       };
74317     } catch (Dali::DaliException e) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74320       };
74321     } catch (...) {
74322       {
74323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74324       };
74325     }
74326   }
74327
74328   jresult = (void *)result;
74329   return jresult;
74330 }
74331
74332
74333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74334   unsigned int jresult ;
74335   Dali::Toolkit::ControlOrientation::Type arg1 ;
74336   bool result;
74337
74338   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74339   {
74340     try {
74341       result = (bool)Dali::Toolkit::IsVertical(arg1);
74342     } catch (std::out_of_range& e) {
74343       {
74344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74345       };
74346     } catch (std::exception& e) {
74347       {
74348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74349       };
74350     } catch (Dali::DaliException e) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74353       };
74354     } catch (...) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74357       };
74358     }
74359   }
74360
74361   jresult = result;
74362   return jresult;
74363 }
74364
74365
74366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74367   unsigned int jresult ;
74368   Dali::Toolkit::ControlOrientation::Type arg1 ;
74369   bool result;
74370
74371   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74372   {
74373     try {
74374       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74375     } catch (std::out_of_range& e) {
74376       {
74377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (std::exception& e) {
74380       {
74381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74382       };
74383     } catch (Dali::DaliException e) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74386       };
74387     } catch (...) {
74388       {
74389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74390       };
74391     }
74392   }
74393
74394   jresult = result;
74395   return jresult;
74396 }
74397
74398
74399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74400   void * jresult ;
74401   unsigned int arg1 ;
74402   unsigned int arg2 ;
74403   Dali::Toolkit::ItemRange *result = 0 ;
74404
74405   arg1 = (unsigned int)jarg1;
74406   arg2 = (unsigned int)jarg2;
74407   {
74408     try {
74409       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74410     } catch (std::out_of_range& e) {
74411       {
74412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74413       };
74414     } catch (std::exception& e) {
74415       {
74416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74417       };
74418     } catch (Dali::DaliException e) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74421       };
74422     } catch (...) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74425       };
74426     }
74427   }
74428
74429   jresult = (void *)result;
74430   return jresult;
74431 }
74432
74433
74434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74435   void * jresult ;
74436   Dali::Toolkit::ItemRange *arg1 = 0 ;
74437   Dali::Toolkit::ItemRange *result = 0 ;
74438
74439   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74440   if (!arg1) {
74441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74442     return 0;
74443   }
74444   {
74445     try {
74446       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (Dali::DaliException e) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74462       };
74463     }
74464   }
74465
74466   jresult = (void *)result;
74467   return jresult;
74468 }
74469
74470
74471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74472   void * jresult ;
74473   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74474   Dali::Toolkit::ItemRange *arg2 = 0 ;
74475   Dali::Toolkit::ItemRange *result = 0 ;
74476
74477   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74478   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74479   if (!arg2) {
74480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74481     return 0;
74482   }
74483   {
74484     try {
74485       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (Dali::DaliException e) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74501       };
74502     }
74503   }
74504
74505   jresult = (void *)result;
74506   return jresult;
74507 }
74508
74509
74510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74511   unsigned int jresult ;
74512   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74513   unsigned int arg2 ;
74514   bool result;
74515
74516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74517   arg2 = (unsigned int)jarg2;
74518   {
74519     try {
74520       result = (bool)(arg1)->Within(arg2);
74521     } catch (std::out_of_range& e) {
74522       {
74523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74524       };
74525     } catch (std::exception& e) {
74526       {
74527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74528       };
74529     } catch (Dali::DaliException e) {
74530       {
74531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74532       };
74533     } catch (...) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74536       };
74537     }
74538   }
74539
74540   jresult = result;
74541   return jresult;
74542 }
74543
74544
74545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74546   void * jresult ;
74547   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74548   Dali::Toolkit::ItemRange *arg2 = 0 ;
74549   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74550
74551   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74552   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74553   if (!arg2) {
74554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74555     return 0;
74556   }
74557   {
74558     try {
74559       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74560     } catch (std::out_of_range& e) {
74561       {
74562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (std::exception& e) {
74565       {
74566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74567       };
74568     } catch (Dali::DaliException e) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74571       };
74572     } catch (...) {
74573       {
74574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74575       };
74576     }
74577   }
74578
74579   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74580   return jresult;
74581 }
74582
74583
74584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74585   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74586   unsigned int arg2 ;
74587
74588   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74589   arg2 = (unsigned int)jarg2;
74590   if (arg1) (arg1)->begin = arg2;
74591 }
74592
74593
74594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74595   unsigned int jresult ;
74596   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74597   unsigned int result;
74598
74599   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74600   result = (unsigned int) ((arg1)->begin);
74601   jresult = result;
74602   return jresult;
74603 }
74604
74605
74606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74607   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74608   unsigned int arg2 ;
74609
74610   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74611   arg2 = (unsigned int)jarg2;
74612   if (arg1) (arg1)->end = arg2;
74613 }
74614
74615
74616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74617   unsigned int jresult ;
74618   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74619   unsigned int result;
74620
74621   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74622   result = (unsigned int) ((arg1)->end);
74623   jresult = result;
74624   return jresult;
74625 }
74626
74627
74628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74629   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74630
74631   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74632   {
74633     try {
74634       delete arg1;
74635     } catch (std::out_of_range& e) {
74636       {
74637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (std::exception& e) {
74640       {
74641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74642       };
74643     } catch (Dali::DaliException e) {
74644       {
74645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74646       };
74647     } catch (...) {
74648       {
74649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74650       };
74651     }
74652   }
74653
74654 }
74655
74656
74657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74658   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74659
74660   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74661   {
74662     try {
74663       delete arg1;
74664     } catch (std::out_of_range& e) {
74665       {
74666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74667       };
74668     } catch (std::exception& e) {
74669       {
74670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74671       };
74672     } catch (Dali::DaliException e) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74675       };
74676     } catch (...) {
74677       {
74678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74679       };
74680     }
74681   }
74682
74683 }
74684
74685
74686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74688   Dali::Toolkit::ControlOrientation::Type arg2 ;
74689
74690   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74691   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74692   {
74693     try {
74694       (arg1)->SetOrientation(arg2);
74695     } catch (std::out_of_range& e) {
74696       {
74697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74698       };
74699     } catch (std::exception& e) {
74700       {
74701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74702       };
74703     } catch (Dali::DaliException e) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74706       };
74707     } catch (...) {
74708       {
74709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74710       };
74711     }
74712   }
74713
74714 }
74715
74716
74717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74718   int jresult ;
74719   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74720   Dali::Toolkit::ControlOrientation::Type result;
74721
74722   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74723   {
74724     try {
74725       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74726     } catch (std::out_of_range& e) {
74727       {
74728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74729       };
74730     } catch (std::exception& e) {
74731       {
74732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74733       };
74734     } catch (Dali::DaliException e) {
74735       {
74736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74737       };
74738     } catch (...) {
74739       {
74740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74741       };
74742     }
74743   }
74744
74745   jresult = (int)result;
74746   return jresult;
74747 }
74748
74749
74750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74751   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74752   Dali::Property::Map *arg2 = 0 ;
74753
74754   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74755   arg2 = (Dali::Property::Map *)jarg2;
74756   if (!arg2) {
74757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74758     return ;
74759   }
74760   {
74761     try {
74762       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74763     } catch (std::out_of_range& e) {
74764       {
74765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74766       };
74767     } catch (std::exception& e) {
74768       {
74769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74770       };
74771     } catch (Dali::DaliException e) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74774       };
74775     } catch (...) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74778       };
74779     }
74780   }
74781
74782 }
74783
74784
74785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74786   void * jresult ;
74787   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74788   Dali::Property::Map result;
74789
74790   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74791   {
74792     try {
74793       result = (arg1)->GetLayoutProperties();
74794     } catch (std::out_of_range& e) {
74795       {
74796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74797       };
74798     } catch (std::exception& e) {
74799       {
74800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74801       };
74802     } catch (Dali::DaliException e) {
74803       {
74804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74805       };
74806     } catch (...) {
74807       {
74808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74809       };
74810     }
74811   }
74812
74813   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74814   return jresult;
74815 }
74816
74817
74818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74820   unsigned int arg2 ;
74821   Dali::Vector3 *arg3 = 0 ;
74822   Dali::Vector3 *arg4 = 0 ;
74823
74824   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74825   arg2 = (unsigned int)jarg2;
74826   arg3 = (Dali::Vector3 *)jarg3;
74827   if (!arg3) {
74828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74829     return ;
74830   }
74831   arg4 = (Dali::Vector3 *)jarg4;
74832   if (!arg4) {
74833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74834     return ;
74835   }
74836   {
74837     try {
74838       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74846       };
74847     } catch (Dali::DaliException e) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74850       };
74851     } catch (...) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74854       };
74855     }
74856   }
74857
74858 }
74859
74860
74861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74863   Dali::Vector3 *arg2 = 0 ;
74864
74865   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74866   arg2 = (Dali::Vector3 *)jarg2;
74867   if (!arg2) {
74868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74869     return ;
74870   }
74871   {
74872     try {
74873       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74874     } catch (std::out_of_range& e) {
74875       {
74876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74877       };
74878     } catch (std::exception& e) {
74879       {
74880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74881       };
74882     } catch (Dali::DaliException e) {
74883       {
74884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74885       };
74886     } catch (...) {
74887       {
74888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74889       };
74890     }
74891   }
74892
74893 }
74894
74895
74896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74897   float jresult ;
74898   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74899   unsigned int arg2 ;
74900   Dali::Vector3 arg3 ;
74901   Dali::Vector3 *argp3 ;
74902   float result;
74903
74904   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74905   arg2 = (unsigned int)jarg2;
74906   argp3 = (Dali::Vector3 *)jarg3;
74907   if (!argp3) {
74908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74909     return 0;
74910   }
74911   arg3 = *argp3;
74912   {
74913     try {
74914       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74915     } catch (std::out_of_range& e) {
74916       {
74917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (std::exception& e) {
74920       {
74921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74922       };
74923     } catch (Dali::DaliException e) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74930       };
74931     }
74932   }
74933
74934   jresult = result;
74935   return jresult;
74936 }
74937
74938
74939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74940   float jresult ;
74941   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74942   float arg2 ;
74943   float result;
74944
74945   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74946   arg2 = (float)jarg2;
74947   {
74948     try {
74949       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74950     } catch (std::out_of_range& e) {
74951       {
74952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (std::exception& e) {
74955       {
74956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (Dali::DaliException e) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74961       };
74962     } catch (...) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74965       };
74966     }
74967   }
74968
74969   jresult = result;
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74975   float jresult ;
74976   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74977   unsigned int arg2 ;
74978   float result;
74979
74980   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74981   arg2 = (unsigned int)jarg2;
74982   {
74983     try {
74984       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74985     } catch (std::out_of_range& e) {
74986       {
74987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (std::exception& e) {
74990       {
74991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (Dali::DaliException e) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74996       };
74997     } catch (...) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75000       };
75001     }
75002   }
75003
75004   jresult = result;
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75010   void * jresult ;
75011   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75012   float arg2 ;
75013   Dali::Vector3 arg3 ;
75014   Dali::Vector3 *argp3 ;
75015   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75016
75017   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75018   arg2 = (float)jarg2;
75019   argp3 = (Dali::Vector3 *)jarg3;
75020   if (!argp3) {
75021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75022     return 0;
75023   }
75024   arg3 = *argp3;
75025   {
75026     try {
75027       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75028     } catch (std::out_of_range& e) {
75029       {
75030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75031       };
75032     } catch (std::exception& e) {
75033       {
75034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75035       };
75036     } catch (Dali::DaliException e) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75039       };
75040     } catch (...) {
75041       {
75042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75043       };
75044     }
75045   }
75046
75047   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75048   return jresult;
75049 }
75050
75051
75052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75053   float jresult ;
75054   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75055   int arg2 ;
75056   float arg3 ;
75057   Dali::Vector3 *arg4 = 0 ;
75058   float result;
75059
75060   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75061   arg2 = (int)jarg2;
75062   arg3 = (float)jarg3;
75063   arg4 = (Dali::Vector3 *)jarg4;
75064   if (!arg4) {
75065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75066     return 0;
75067   }
75068   {
75069     try {
75070       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75071     } catch (std::out_of_range& e) {
75072       {
75073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75074       };
75075     } catch (std::exception& e) {
75076       {
75077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75078       };
75079     } catch (Dali::DaliException e) {
75080       {
75081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75082       };
75083     } catch (...) {
75084       {
75085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75086       };
75087     }
75088   }
75089
75090   jresult = result;
75091   return jresult;
75092 }
75093
75094
75095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75096   unsigned int jresult ;
75097   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75098   Dali::Vector3 arg2 ;
75099   Dali::Vector3 *argp2 ;
75100   unsigned int result;
75101
75102   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75103   argp2 = (Dali::Vector3 *)jarg2;
75104   if (!argp2) {
75105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75106     return 0;
75107   }
75108   arg2 = *argp2;
75109   {
75110     try {
75111       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75112     } catch (std::out_of_range& e) {
75113       {
75114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (std::exception& e) {
75117       {
75118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75119       };
75120     } catch (Dali::DaliException e) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75123       };
75124     } catch (...) {
75125       {
75126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75127       };
75128     }
75129   }
75130
75131   jresult = result;
75132   return jresult;
75133 }
75134
75135
75136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75137   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75138   unsigned int arg2 ;
75139   Dali::Vector3 *arg3 = 0 ;
75140   Dali::Vector3 *arg4 = 0 ;
75141
75142   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75143   arg2 = (unsigned int)jarg2;
75144   arg3 = (Dali::Vector3 *)jarg3;
75145   if (!arg3) {
75146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75147     return ;
75148   }
75149   arg4 = (Dali::Vector3 *)jarg4;
75150   if (!arg4) {
75151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75152     return ;
75153   }
75154   {
75155     try {
75156       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75157     } catch (std::out_of_range& e) {
75158       {
75159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75160       };
75161     } catch (std::exception& e) {
75162       {
75163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75164       };
75165     } catch (Dali::DaliException e) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75168       };
75169     } catch (...) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75172       };
75173     }
75174   }
75175
75176 }
75177
75178
75179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75180   void * jresult ;
75181   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75182   Dali::Degree result;
75183
75184   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75185   {
75186     try {
75187       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75188     } catch (std::out_of_range& e) {
75189       {
75190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75191       };
75192     } catch (std::exception& e) {
75193       {
75194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75195       };
75196     } catch (Dali::DaliException e) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75199       };
75200     } catch (...) {
75201       {
75202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75203       };
75204     }
75205   }
75206
75207   jresult = new Dali::Degree((const Dali::Degree &)result);
75208   return jresult;
75209 }
75210
75211
75212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75213   float jresult ;
75214   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75215   float result;
75216
75217   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75218   {
75219     try {
75220       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75221     } catch (std::out_of_range& e) {
75222       {
75223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (std::exception& e) {
75226       {
75227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75228       };
75229     } catch (Dali::DaliException e) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75232       };
75233     } catch (...) {
75234       {
75235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75236       };
75237     }
75238   }
75239
75240   jresult = result;
75241   return jresult;
75242 }
75243
75244
75245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75246   float jresult ;
75247   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75248   float result;
75249
75250   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75251   {
75252     try {
75253       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75254     } catch (std::out_of_range& e) {
75255       {
75256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75257       };
75258     } catch (std::exception& e) {
75259       {
75260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75261       };
75262     } catch (Dali::DaliException e) {
75263       {
75264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75265       };
75266     } catch (...) {
75267       {
75268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75269       };
75270     }
75271   }
75272
75273   jresult = result;
75274   return jresult;
75275 }
75276
75277
75278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75279   float jresult ;
75280   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75281   float result;
75282
75283   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75284   {
75285     try {
75286       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75287     } catch (std::out_of_range& e) {
75288       {
75289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (std::exception& e) {
75292       {
75293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (Dali::DaliException e) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75298       };
75299     } catch (...) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75302       };
75303     }
75304   }
75305
75306   jresult = result;
75307   return jresult;
75308 }
75309
75310
75311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75312   int jresult ;
75313   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75314   int arg2 ;
75315   int arg3 ;
75316   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75317   bool arg5 ;
75318   int result;
75319
75320   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75321   arg2 = (int)jarg2;
75322   arg3 = (int)jarg3;
75323   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75324   arg5 = jarg5 ? true : false;
75325   {
75326     try {
75327       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75328     } catch (std::out_of_range& e) {
75329       {
75330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (std::exception& e) {
75333       {
75334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75335       };
75336     } catch (Dali::DaliException e) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75339       };
75340     } catch (...) {
75341       {
75342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75343       };
75344     }
75345   }
75346
75347   jresult = result;
75348   return jresult;
75349 }
75350
75351
75352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75353   float jresult ;
75354   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75355   float result;
75356
75357   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75358   {
75359     try {
75360       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75361     } catch (std::out_of_range& e) {
75362       {
75363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75364       };
75365     } catch (std::exception& e) {
75366       {
75367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75368       };
75369     } catch (Dali::DaliException e) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75372       };
75373     } catch (...) {
75374       {
75375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75376       };
75377     }
75378   }
75379
75380   jresult = result;
75381   return jresult;
75382 }
75383
75384
75385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75386   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75387   Dali::Actor *arg2 = 0 ;
75388   int arg3 ;
75389   Dali::Vector3 *arg4 = 0 ;
75390   Dali::Actor *arg5 = 0 ;
75391
75392   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75393   arg2 = (Dali::Actor *)jarg2;
75394   if (!arg2) {
75395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75396     return ;
75397   }
75398   arg3 = (int)jarg3;
75399   arg4 = (Dali::Vector3 *)jarg4;
75400   if (!arg4) {
75401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75402     return ;
75403   }
75404   arg5 = (Dali::Actor *)jarg5;
75405   if (!arg5) {
75406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75407     return ;
75408   }
75409   {
75410     try {
75411       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75412     } catch (std::out_of_range& e) {
75413       {
75414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75415       };
75416     } catch (std::exception& e) {
75417       {
75418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75419       };
75420     } catch (Dali::DaliException e) {
75421       {
75422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75423       };
75424     } catch (...) {
75425       {
75426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75427       };
75428     }
75429   }
75430
75431 }
75432
75433
75434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75435   void * jresult ;
75436   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75437   int arg2 ;
75438   float arg3 ;
75439   Dali::Vector3 *arg4 = 0 ;
75440   Dali::Vector3 result;
75441
75442   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75443   arg2 = (int)jarg2;
75444   arg3 = (float)jarg3;
75445   arg4 = (Dali::Vector3 *)jarg4;
75446   if (!arg4) {
75447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75448     return 0;
75449   }
75450   {
75451     try {
75452       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75453     } catch (std::out_of_range& e) {
75454       {
75455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (std::exception& e) {
75458       {
75459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75460       };
75461     } catch (Dali::DaliException e) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75464       };
75465     } catch (...) {
75466       {
75467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75468       };
75469     }
75470   }
75471
75472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75473   return jresult;
75474 }
75475
75476
75477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75478   void * jresult ;
75479   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75480   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75481
75482   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75483   {
75484     try {
75485       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75486     } catch (std::out_of_range& e) {
75487       {
75488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75489       };
75490     } catch (std::exception& e) {
75491       {
75492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75493       };
75494     } catch (Dali::DaliException e) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75497       };
75498     } catch (...) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75501       };
75502     }
75503   }
75504
75505   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75506   return jresult;
75507 }
75508
75509
75510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75511   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75512
75513   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75514   {
75515     try {
75516       delete arg1;
75517     } catch (std::out_of_range& e) {
75518       {
75519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75520       };
75521     } catch (std::exception& e) {
75522       {
75523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75524       };
75525     } catch (Dali::DaliException e) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75528       };
75529     } catch (...) {
75530       {
75531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75532       };
75533     }
75534   }
75535
75536 }
75537
75538
75539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75540   unsigned int jresult ;
75541   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75542   unsigned int result;
75543
75544   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75545   {
75546     try {
75547       result = (unsigned int)(arg1)->GetNumberOfItems();
75548     } catch (std::out_of_range& e) {
75549       {
75550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75551       };
75552     } catch (std::exception& e) {
75553       {
75554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75555       };
75556     } catch (Dali::DaliException e) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75559       };
75560     } catch (...) {
75561       {
75562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75563       };
75564     }
75565   }
75566
75567   jresult = result;
75568   return jresult;
75569 }
75570
75571
75572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75573   void * jresult ;
75574   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75575   unsigned int arg2 ;
75576   Dali::Actor result;
75577
75578   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75579   arg2 = (unsigned int)jarg2;
75580   {
75581     try {
75582       result = (arg1)->NewItem(arg2);
75583     } catch (std::out_of_range& e) {
75584       {
75585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (std::exception& e) {
75588       {
75589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75590       };
75591     } catch (Dali::DaliException e) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75594       };
75595     } catch (...) {
75596       {
75597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75598       };
75599     }
75600   }
75601
75602   jresult = new Dali::Actor((const Dali::Actor &)result);
75603   return jresult;
75604 }
75605
75606
75607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75608   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75609   unsigned int arg2 ;
75610   Dali::Actor arg3 ;
75611   Dali::Actor *argp3 ;
75612
75613   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75614   arg2 = (unsigned int)jarg2;
75615   argp3 = (Dali::Actor *)jarg3;
75616   if (!argp3) {
75617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75618     return ;
75619   }
75620   arg3 = *argp3;
75621   {
75622     try {
75623       (arg1)->ItemReleased(arg2,arg3);
75624     } catch (std::out_of_range& e) {
75625       {
75626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (std::exception& e) {
75629       {
75630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75631       };
75632     } catch (Dali::DaliException e) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75635       };
75636     } catch (...) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75639       };
75640     }
75641   }
75642
75643 }
75644
75645
75646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75647   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75648   unsigned int arg2 ;
75649   Dali::Actor arg3 ;
75650   Dali::Actor *argp3 ;
75651
75652   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75653   arg2 = (unsigned int)jarg2;
75654   argp3 = (Dali::Actor *)jarg3;
75655   if (!argp3) {
75656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75657     return ;
75658   }
75659   arg3 = *argp3;
75660   {
75661     try {
75662       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75670       };
75671     } catch (Dali::DaliException e) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75678       };
75679     }
75680   }
75681
75682 }
75683
75684
75685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75686   void * jresult ;
75687   Dali::Toolkit::ItemFactory *result = 0 ;
75688
75689   {
75690     try {
75691       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75692     } catch (std::out_of_range& e) {
75693       {
75694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75695       };
75696     } catch (std::exception& e) {
75697       {
75698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75699       };
75700     } catch (Dali::DaliException e) {
75701       {
75702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75703       };
75704     } catch (...) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75707       };
75708     }
75709   }
75710
75711   jresult = (void *)result;
75712   return jresult;
75713 }
75714
75715
75716 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) {
75717   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75718   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75719   if (director) {
75720     director->swig_connect_director(callback0, callback1, callback2);
75721   }
75722 }
75723
75724
75725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75726   int jresult ;
75727   int result;
75728
75729   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75730   jresult = (int)result;
75731   return jresult;
75732 }
75733
75734
75735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75736   int jresult ;
75737   int result;
75738
75739   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75740   jresult = (int)result;
75741   return jresult;
75742 }
75743
75744
75745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75746   int jresult ;
75747   int result;
75748
75749   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75750   jresult = (int)result;
75751   return jresult;
75752 }
75753
75754
75755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75756   int jresult ;
75757   int result;
75758
75759   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75760   jresult = (int)result;
75761   return jresult;
75762 }
75763
75764
75765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75766   int jresult ;
75767   int result;
75768
75769   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75770   jresult = (int)result;
75771   return jresult;
75772 }
75773
75774
75775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75776   int jresult ;
75777   int result;
75778
75779   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75780   jresult = (int)result;
75781   return jresult;
75782 }
75783
75784
75785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75786   int jresult ;
75787   int result;
75788
75789   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75790   jresult = (int)result;
75791   return jresult;
75792 }
75793
75794
75795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75796   int jresult ;
75797   int result;
75798
75799   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75800   jresult = (int)result;
75801   return jresult;
75802 }
75803
75804
75805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75806   int jresult ;
75807   int result;
75808
75809   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75810   jresult = (int)result;
75811   return jresult;
75812 }
75813
75814
75815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75816   int jresult ;
75817   int result;
75818
75819   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75820   jresult = (int)result;
75821   return jresult;
75822 }
75823
75824
75825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75826   int jresult ;
75827   int result;
75828
75829   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75830   jresult = (int)result;
75831   return jresult;
75832 }
75833
75834
75835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75836   void * jresult ;
75837   Dali::Toolkit::ItemView::Property *result = 0 ;
75838
75839   {
75840     try {
75841       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (Dali::DaliException e) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75857       };
75858     }
75859   }
75860
75861   jresult = (void *)result;
75862   return jresult;
75863 }
75864
75865
75866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75867   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75868
75869   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75870   {
75871     try {
75872       delete arg1;
75873     } catch (std::out_of_range& e) {
75874       {
75875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (std::exception& e) {
75878       {
75879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75880       };
75881     } catch (Dali::DaliException e) {
75882       {
75883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75884       };
75885     } catch (...) {
75886       {
75887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75888       };
75889     }
75890   }
75891
75892 }
75893
75894
75895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75896   void * jresult ;
75897   Dali::Toolkit::ItemView *result = 0 ;
75898
75899   {
75900     try {
75901       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75902     } catch (std::out_of_range& e) {
75903       {
75904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75905       };
75906     } catch (std::exception& e) {
75907       {
75908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75909       };
75910     } catch (Dali::DaliException e) {
75911       {
75912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75913       };
75914     } catch (...) {
75915       {
75916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75917       };
75918     }
75919   }
75920
75921   jresult = (void *)result;
75922   return jresult;
75923 }
75924
75925
75926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75927   void * jresult ;
75928   Dali::Toolkit::ItemView *arg1 = 0 ;
75929   Dali::Toolkit::ItemView *result = 0 ;
75930
75931   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75932   if (!arg1) {
75933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75934     return 0;
75935   }
75936   {
75937     try {
75938       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75939     } catch (std::out_of_range& e) {
75940       {
75941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75942       };
75943     } catch (std::exception& e) {
75944       {
75945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75946       };
75947     } catch (Dali::DaliException e) {
75948       {
75949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75950       };
75951     } catch (...) {
75952       {
75953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75954       };
75955     }
75956   }
75957
75958   jresult = (void *)result;
75959   return jresult;
75960 }
75961
75962
75963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75964   void * jresult ;
75965   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75966   Dali::Toolkit::ItemView *arg2 = 0 ;
75967   Dali::Toolkit::ItemView *result = 0 ;
75968
75969   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75970   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75971   if (!arg2) {
75972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75973     return 0;
75974   }
75975   {
75976     try {
75977       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75978     } catch (std::out_of_range& e) {
75979       {
75980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75981       };
75982     } catch (std::exception& e) {
75983       {
75984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75985       };
75986     } catch (Dali::DaliException e) {
75987       {
75988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75989       };
75990     } catch (...) {
75991       {
75992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75993       };
75994     }
75995   }
75996
75997   jresult = (void *)result;
75998   return jresult;
75999 }
76000
76001
76002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76003   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76004
76005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76006   {
76007     try {
76008       delete arg1;
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76016       };
76017     } catch (Dali::DaliException e) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76020       };
76021     } catch (...) {
76022       {
76023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76024       };
76025     }
76026   }
76027
76028 }
76029
76030
76031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76032   void * jresult ;
76033   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76034   Dali::Toolkit::ItemView result;
76035
76036   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76037   if (!arg1) {
76038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76039     return 0;
76040   }
76041   {
76042     try {
76043       result = Dali::Toolkit::ItemView::New(*arg1);
76044     } catch (std::out_of_range& e) {
76045       {
76046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (std::exception& e) {
76049       {
76050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (Dali::DaliException e) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76055       };
76056     } catch (...) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76059       };
76060     }
76061   }
76062
76063   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76064   return jresult;
76065 }
76066
76067
76068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76069   void * jresult ;
76070   Dali::BaseHandle arg1 ;
76071   Dali::BaseHandle *argp1 ;
76072   Dali::Toolkit::ItemView result;
76073
76074   argp1 = (Dali::BaseHandle *)jarg1;
76075   if (!argp1) {
76076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76077     return 0;
76078   }
76079   arg1 = *argp1;
76080   {
76081     try {
76082       result = Dali::Toolkit::ItemView::DownCast(arg1);
76083     } catch (std::out_of_range& e) {
76084       {
76085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (std::exception& e) {
76088       {
76089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76090       };
76091     } catch (Dali::DaliException e) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76098       };
76099     }
76100   }
76101
76102   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76103   return jresult;
76104 }
76105
76106
76107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76108   unsigned int jresult ;
76109   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76110   unsigned int result;
76111
76112   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76113   {
76114     try {
76115       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76116     } catch (std::out_of_range& e) {
76117       {
76118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76119       };
76120     } catch (std::exception& e) {
76121       {
76122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (Dali::DaliException e) {
76125       {
76126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76127       };
76128     } catch (...) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76131       };
76132     }
76133   }
76134
76135   jresult = result;
76136   return jresult;
76137 }
76138
76139
76140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76142   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76143
76144   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76145   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76146   if (!arg2) {
76147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76148     return ;
76149   }
76150   {
76151     try {
76152       (arg1)->AddLayout(*arg2);
76153     } catch (std::out_of_range& e) {
76154       {
76155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76156       };
76157     } catch (std::exception& e) {
76158       {
76159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76160       };
76161     } catch (Dali::DaliException e) {
76162       {
76163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76164       };
76165     } catch (...) {
76166       {
76167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76168       };
76169     }
76170   }
76171
76172 }
76173
76174
76175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76176   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76177   unsigned int arg2 ;
76178
76179   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76180   arg2 = (unsigned int)jarg2;
76181   {
76182     try {
76183       (arg1)->RemoveLayout(arg2);
76184     } catch (std::out_of_range& e) {
76185       {
76186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76187       };
76188     } catch (std::exception& e) {
76189       {
76190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76191       };
76192     } catch (Dali::DaliException e) {
76193       {
76194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76195       };
76196     } catch (...) {
76197       {
76198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76199       };
76200     }
76201   }
76202
76203 }
76204
76205
76206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76207   void * jresult ;
76208   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76209   unsigned int arg2 ;
76210   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76211
76212   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76213   arg2 = (unsigned int)jarg2;
76214   {
76215     try {
76216       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76217     } catch (std::out_of_range& e) {
76218       {
76219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76220       };
76221     } catch (std::exception& e) {
76222       {
76223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76224       };
76225     } catch (Dali::DaliException e) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76228       };
76229     } catch (...) {
76230       {
76231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76232       };
76233     }
76234   }
76235
76236   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76237   return jresult;
76238 }
76239
76240
76241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76242   void * jresult ;
76243   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76244   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76245
76246   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76247   {
76248     try {
76249       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76250     } catch (std::out_of_range& e) {
76251       {
76252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76253       };
76254     } catch (std::exception& e) {
76255       {
76256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76257       };
76258     } catch (Dali::DaliException e) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76261       };
76262     } catch (...) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76265       };
76266     }
76267   }
76268
76269   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76270   return jresult;
76271 }
76272
76273
76274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76275   float jresult ;
76276   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76277   Dali::Toolkit::ItemId arg2 ;
76278   float result;
76279
76280   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76281   arg2 = (Dali::Toolkit::ItemId)jarg2;
76282   {
76283     try {
76284       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76285     } catch (std::out_of_range& e) {
76286       {
76287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76288       };
76289     } catch (std::exception& e) {
76290       {
76291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76292       };
76293     } catch (Dali::DaliException e) {
76294       {
76295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76296       };
76297     } catch (...) {
76298       {
76299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76300       };
76301     }
76302   }
76303
76304   jresult = result;
76305   return jresult;
76306 }
76307
76308
76309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76310   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76311   unsigned int arg2 ;
76312   Dali::Vector3 arg3 ;
76313   float arg4 ;
76314   Dali::Vector3 *argp3 ;
76315
76316   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76317   arg2 = (unsigned int)jarg2;
76318   argp3 = (Dali::Vector3 *)jarg3;
76319   if (!argp3) {
76320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76321     return ;
76322   }
76323   arg3 = *argp3;
76324   arg4 = (float)jarg4;
76325   {
76326     try {
76327       (arg1)->ActivateLayout(arg2,arg3,arg4);
76328     } catch (std::out_of_range& e) {
76329       {
76330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (std::exception& e) {
76333       {
76334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76335       };
76336     } catch (Dali::DaliException e) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76339       };
76340     } catch (...) {
76341       {
76342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76343       };
76344     }
76345   }
76346
76347 }
76348
76349
76350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76351   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76352
76353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76354   {
76355     try {
76356       (arg1)->DeactivateCurrentLayout();
76357     } catch (std::out_of_range& e) {
76358       {
76359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (std::exception& e) {
76362       {
76363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76364       };
76365     } catch (Dali::DaliException e) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76368       };
76369     } catch (...) {
76370       {
76371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76372       };
76373     }
76374   }
76375
76376 }
76377
76378
76379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76381   float arg2 ;
76382
76383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76384   arg2 = (float)jarg2;
76385   {
76386     try {
76387       (arg1)->SetMinimumSwipeSpeed(arg2);
76388     } catch (std::out_of_range& e) {
76389       {
76390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (std::exception& e) {
76393       {
76394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76395       };
76396     } catch (Dali::DaliException e) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76399       };
76400     } catch (...) {
76401       {
76402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76403       };
76404     }
76405   }
76406
76407 }
76408
76409
76410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76411   float jresult ;
76412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76413   float result;
76414
76415   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76416   {
76417     try {
76418       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76419     } catch (std::out_of_range& e) {
76420       {
76421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76422       };
76423     } catch (std::exception& e) {
76424       {
76425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76426       };
76427     } catch (Dali::DaliException e) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76430       };
76431     } catch (...) {
76432       {
76433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76434       };
76435     }
76436   }
76437
76438   jresult = result;
76439   return jresult;
76440 }
76441
76442
76443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76444   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76445   float arg2 ;
76446
76447   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76448   arg2 = (float)jarg2;
76449   {
76450     try {
76451       (arg1)->SetMinimumSwipeDistance(arg2);
76452     } catch (std::out_of_range& e) {
76453       {
76454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76455       };
76456     } catch (std::exception& e) {
76457       {
76458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76459       };
76460     } catch (Dali::DaliException e) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76463       };
76464     } catch (...) {
76465       {
76466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76467       };
76468     }
76469   }
76470
76471 }
76472
76473
76474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76475   float jresult ;
76476   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76477   float result;
76478
76479   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76480   {
76481     try {
76482       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76483     } catch (std::out_of_range& e) {
76484       {
76485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76486       };
76487     } catch (std::exception& e) {
76488       {
76489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76490       };
76491     } catch (Dali::DaliException e) {
76492       {
76493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76494       };
76495     } catch (...) {
76496       {
76497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76498       };
76499     }
76500   }
76501
76502   jresult = result;
76503   return jresult;
76504 }
76505
76506
76507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76508   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76509   float arg2 ;
76510
76511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76512   arg2 = (float)jarg2;
76513   {
76514     try {
76515       (arg1)->SetWheelScrollDistanceStep(arg2);
76516     } catch (std::out_of_range& e) {
76517       {
76518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76519       };
76520     } catch (std::exception& e) {
76521       {
76522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76523       };
76524     } catch (Dali::DaliException e) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76527       };
76528     } catch (...) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76531       };
76532     }
76533   }
76534
76535 }
76536
76537
76538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76539   float jresult ;
76540   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76541   float result;
76542
76543   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76544   {
76545     try {
76546       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76547     } catch (std::out_of_range& e) {
76548       {
76549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (std::exception& e) {
76552       {
76553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (Dali::DaliException e) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76562       };
76563     }
76564   }
76565
76566   jresult = result;
76567   return jresult;
76568 }
76569
76570
76571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76572   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76573   bool arg2 ;
76574
76575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76576   arg2 = jarg2 ? true : false;
76577   {
76578     try {
76579       (arg1)->SetAnchoring(arg2);
76580     } catch (std::out_of_range& e) {
76581       {
76582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76583       };
76584     } catch (std::exception& e) {
76585       {
76586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76587       };
76588     } catch (Dali::DaliException e) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76591       };
76592     } catch (...) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76595       };
76596     }
76597   }
76598
76599 }
76600
76601 //// ========================= end of part 3 =============================
76602
76603 //// ========================== start part 4 ===============================
76604
76605
76606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76607   unsigned int jresult ;
76608   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76609   bool result;
76610
76611   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76612   {
76613     try {
76614       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76615     } catch (std::out_of_range& e) {
76616       {
76617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76618       };
76619     } catch (std::exception& e) {
76620       {
76621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76622       };
76623     } catch (Dali::DaliException e) {
76624       {
76625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76626       };
76627     } catch (...) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76630       };
76631     }
76632   }
76633
76634   jresult = result;
76635   return jresult;
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76641   float arg2 ;
76642
76643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76644   arg2 = (float)jarg2;
76645   {
76646     try {
76647       (arg1)->SetAnchoringDuration(arg2);
76648     } catch (std::out_of_range& e) {
76649       {
76650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (std::exception& e) {
76653       {
76654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (Dali::DaliException e) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76663       };
76664     }
76665   }
76666
76667 }
76668
76669
76670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76671   float jresult ;
76672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76673   float result;
76674
76675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76676   {
76677     try {
76678       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76686       };
76687     } catch (Dali::DaliException e) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76690       };
76691     } catch (...) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76694       };
76695     }
76696   }
76697
76698   jresult = result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76705   Dali::Toolkit::ItemId arg2 ;
76706   float arg3 ;
76707
76708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76709   arg2 = (Dali::Toolkit::ItemId)jarg2;
76710   arg3 = (float)jarg3;
76711   {
76712     try {
76713       (arg1)->ScrollToItem(arg2,arg3);
76714     } catch (std::out_of_range& e) {
76715       {
76716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (std::exception& e) {
76719       {
76720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76721       };
76722     } catch (Dali::DaliException e) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76729       };
76730     }
76731   }
76732
76733 }
76734
76735
76736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76738   float arg2 ;
76739
76740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76741   arg2 = (float)jarg2;
76742   {
76743     try {
76744       (arg1)->SetRefreshInterval(arg2);
76745     } catch (std::out_of_range& e) {
76746       {
76747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76748       };
76749     } catch (std::exception& e) {
76750       {
76751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76752       };
76753     } catch (Dali::DaliException e) {
76754       {
76755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76756       };
76757     } catch (...) {
76758       {
76759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76760       };
76761     }
76762   }
76763
76764 }
76765
76766
76767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76768   float jresult ;
76769   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76770   float result;
76771
76772   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76773   {
76774     try {
76775       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76776     } catch (std::out_of_range& e) {
76777       {
76778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76779       };
76780     } catch (std::exception& e) {
76781       {
76782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76783       };
76784     } catch (Dali::DaliException e) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76787       };
76788     } catch (...) {
76789       {
76790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76791       };
76792     }
76793   }
76794
76795   jresult = result;
76796   return jresult;
76797 }
76798
76799
76800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76801   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76802
76803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76804   {
76805     try {
76806       (arg1)->Refresh();
76807     } catch (std::out_of_range& e) {
76808       {
76809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76810       };
76811     } catch (std::exception& e) {
76812       {
76813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76814       };
76815     } catch (Dali::DaliException e) {
76816       {
76817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76818       };
76819     } catch (...) {
76820       {
76821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76822       };
76823     }
76824   }
76825
76826 }
76827
76828
76829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76830   void * jresult ;
76831   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76832   Dali::Toolkit::ItemId arg2 ;
76833   Dali::Actor result;
76834
76835   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76836   arg2 = (Dali::Toolkit::ItemId)jarg2;
76837   {
76838     try {
76839       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76840     } catch (std::out_of_range& e) {
76841       {
76842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76843       };
76844     } catch (std::exception& e) {
76845       {
76846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76847       };
76848     } catch (Dali::DaliException e) {
76849       {
76850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76851       };
76852     } catch (...) {
76853       {
76854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76855       };
76856     }
76857   }
76858
76859   jresult = new Dali::Actor((const Dali::Actor &)result);
76860   return jresult;
76861 }
76862
76863
76864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76865   unsigned int jresult ;
76866   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76867   Dali::Actor arg2 ;
76868   Dali::Actor *argp2 ;
76869   Dali::Toolkit::ItemId result;
76870
76871   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76872   argp2 = (Dali::Actor *)jarg2;
76873   if (!argp2) {
76874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76875     return 0;
76876   }
76877   arg2 = *argp2;
76878   {
76879     try {
76880       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76881     } catch (std::out_of_range& e) {
76882       {
76883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76884       };
76885     } catch (std::exception& e) {
76886       {
76887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76888       };
76889     } catch (Dali::DaliException e) {
76890       {
76891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76892       };
76893     } catch (...) {
76894       {
76895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76896       };
76897     }
76898   }
76899
76900   jresult = result;
76901   return jresult;
76902 }
76903
76904
76905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76906   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76907   Dali::Toolkit::Item arg2 ;
76908   float arg3 ;
76909   Dali::Toolkit::Item *argp2 ;
76910
76911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76912   argp2 = (Dali::Toolkit::Item *)jarg2;
76913   if (!argp2) {
76914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76915     return ;
76916   }
76917   arg2 = *argp2;
76918   arg3 = (float)jarg3;
76919   {
76920     try {
76921       (arg1)->InsertItem(arg2,arg3);
76922     } catch (std::out_of_range& e) {
76923       {
76924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76925       };
76926     } catch (std::exception& e) {
76927       {
76928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76929       };
76930     } catch (Dali::DaliException e) {
76931       {
76932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76933       };
76934     } catch (...) {
76935       {
76936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76937       };
76938     }
76939   }
76940
76941 }
76942
76943
76944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76946   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76947   float arg3 ;
76948
76949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76950   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76951   if (!arg2) {
76952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76953     return ;
76954   }
76955   arg3 = (float)jarg3;
76956   {
76957     try {
76958       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76959     } catch (std::out_of_range& e) {
76960       {
76961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76962       };
76963     } catch (std::exception& e) {
76964       {
76965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76966       };
76967     } catch (Dali::DaliException e) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76970       };
76971     } catch (...) {
76972       {
76973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76974       };
76975     }
76976   }
76977
76978 }
76979
76980
76981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76982   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76983   Dali::Toolkit::ItemId arg2 ;
76984   float arg3 ;
76985
76986   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76987   arg2 = (Dali::Toolkit::ItemId)jarg2;
76988   arg3 = (float)jarg3;
76989   {
76990     try {
76991       (arg1)->RemoveItem(arg2,arg3);
76992     } catch (std::out_of_range& e) {
76993       {
76994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (std::exception& e) {
76997       {
76998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76999       };
77000     } catch (Dali::DaliException e) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77003       };
77004     } catch (...) {
77005       {
77006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77007       };
77008     }
77009   }
77010
77011 }
77012
77013
77014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77015   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77016   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77017   float arg3 ;
77018
77019   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77020   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77021   if (!arg2) {
77022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77023     return ;
77024   }
77025   arg3 = (float)jarg3;
77026   {
77027     try {
77028       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77029     } catch (std::out_of_range& e) {
77030       {
77031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77032       };
77033     } catch (std::exception& e) {
77034       {
77035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77036       };
77037     } catch (Dali::DaliException e) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77040       };
77041     } catch (...) {
77042       {
77043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77044       };
77045     }
77046   }
77047
77048 }
77049
77050
77051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77052   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77053   Dali::Toolkit::Item arg2 ;
77054   float arg3 ;
77055   Dali::Toolkit::Item *argp2 ;
77056
77057   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77058   argp2 = (Dali::Toolkit::Item *)jarg2;
77059   if (!argp2) {
77060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77061     return ;
77062   }
77063   arg2 = *argp2;
77064   arg3 = (float)jarg3;
77065   {
77066     try {
77067       (arg1)->ReplaceItem(arg2,arg3);
77068     } catch (std::out_of_range& e) {
77069       {
77070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77071       };
77072     } catch (std::exception& e) {
77073       {
77074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77075       };
77076     } catch (Dali::DaliException e) {
77077       {
77078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77079       };
77080     } catch (...) {
77081       {
77082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77083       };
77084     }
77085   }
77086
77087 }
77088
77089
77090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77091   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77092   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77093   float arg3 ;
77094
77095   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77096   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77097   if (!arg2) {
77098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77099     return ;
77100   }
77101   arg3 = (float)jarg3;
77102   {
77103     try {
77104       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77105     } catch (std::out_of_range& e) {
77106       {
77107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77108       };
77109     } catch (std::exception& e) {
77110       {
77111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77112       };
77113     } catch (Dali::DaliException e) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77116       };
77117     } catch (...) {
77118       {
77119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77120       };
77121     }
77122   }
77123
77124 }
77125
77126
77127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77128   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77129   Dali::Vector3 *arg2 = 0 ;
77130
77131   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77132   arg2 = (Dali::Vector3 *)jarg2;
77133   if (!arg2) {
77134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77135     return ;
77136   }
77137   {
77138     try {
77139       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77140     } catch (std::out_of_range& e) {
77141       {
77142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77143       };
77144     } catch (std::exception& e) {
77145       {
77146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77147       };
77148     } catch (Dali::DaliException e) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77151       };
77152     } catch (...) {
77153       {
77154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77155       };
77156     }
77157   }
77158
77159 }
77160
77161
77162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77163   void * jresult ;
77164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77165   Dali::Vector3 result;
77166
77167   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77168   {
77169     try {
77170       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77171     } catch (std::out_of_range& e) {
77172       {
77173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77174       };
77175     } catch (std::exception& e) {
77176       {
77177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77178       };
77179     } catch (Dali::DaliException e) {
77180       {
77181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77182       };
77183     } catch (...) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77186       };
77187     }
77188   }
77189
77190   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77191   return jresult;
77192 }
77193
77194
77195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77196   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77197   Dali::Vector3 *arg2 = 0 ;
77198
77199   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77200   arg2 = (Dali::Vector3 *)jarg2;
77201   if (!arg2) {
77202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77203     return ;
77204   }
77205   {
77206     try {
77207       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77208     } catch (std::out_of_range& e) {
77209       {
77210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77211       };
77212     } catch (std::exception& e) {
77213       {
77214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77215       };
77216     } catch (Dali::DaliException e) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77219       };
77220     } catch (...) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77223       };
77224     }
77225   }
77226
77227 }
77228
77229
77230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77231   void * jresult ;
77232   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77233   Dali::Vector3 result;
77234
77235   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77236   {
77237     try {
77238       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77239     } catch (std::out_of_range& e) {
77240       {
77241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (std::exception& e) {
77244       {
77245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77246       };
77247     } catch (Dali::DaliException e) {
77248       {
77249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77250       };
77251     } catch (...) {
77252       {
77253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77254       };
77255     }
77256   }
77257
77258   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77259   return jresult;
77260 }
77261
77262
77263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77265   Dali::Toolkit::ItemRange *arg2 = 0 ;
77266
77267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77268   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77269   if (!arg2) {
77270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77271     return ;
77272   }
77273   {
77274     try {
77275       (arg1)->GetItemsRange(*arg2);
77276     } catch (std::out_of_range& e) {
77277       {
77278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77279       };
77280     } catch (std::exception& e) {
77281       {
77282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77283       };
77284     } catch (Dali::DaliException e) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77287       };
77288     } catch (...) {
77289       {
77290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77291       };
77292     }
77293   }
77294
77295 }
77296
77297
77298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77299   void * jresult ;
77300   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77301   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77302
77303   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77304   {
77305     try {
77306       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77307     } catch (std::out_of_range& e) {
77308       {
77309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77310       };
77311     } catch (std::exception& e) {
77312       {
77313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77314       };
77315     } catch (Dali::DaliException e) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77318       };
77319     } catch (...) {
77320       {
77321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77322       };
77323     }
77324   }
77325
77326   jresult = (void *)result;
77327   return jresult;
77328 }
77329
77330
77331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77332   Dali::Vector3 *arg1 = 0 ;
77333   PropertyInputContainer *arg2 = 0 ;
77334
77335   arg1 = (Dali::Vector3 *)jarg1;
77336   if (!arg1) {
77337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77338     return ;
77339   }
77340   arg2 = (PropertyInputContainer *)jarg2;
77341   if (!arg2) {
77342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77343     return ;
77344   }
77345   {
77346     try {
77347       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77348     } catch (std::out_of_range& e) {
77349       {
77350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (std::exception& e) {
77353       {
77354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77355       };
77356     } catch (Dali::DaliException e) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77359       };
77360     } catch (...) {
77361       {
77362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77363       };
77364     }
77365   }
77366
77367 }
77368
77369
77370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77371   Dali::Vector3 *arg1 = 0 ;
77372   PropertyInputContainer *arg2 = 0 ;
77373
77374   arg1 = (Dali::Vector3 *)jarg1;
77375   if (!arg1) {
77376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77377     return ;
77378   }
77379   arg2 = (PropertyInputContainer *)jarg2;
77380   if (!arg2) {
77381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77382     return ;
77383   }
77384   {
77385     try {
77386       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77387     } catch (std::out_of_range& e) {
77388       {
77389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77390       };
77391     } catch (std::exception& e) {
77392       {
77393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77394       };
77395     } catch (Dali::DaliException e) {
77396       {
77397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77398       };
77399     } catch (...) {
77400       {
77401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77402       };
77403     }
77404   }
77405
77406 }
77407
77408
77409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77410   void * jresult ;
77411   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77412
77413   {
77414     try {
77415       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77416     } catch (std::out_of_range& e) {
77417       {
77418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77419       };
77420     } catch (std::exception& e) {
77421       {
77422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77423       };
77424     } catch (Dali::DaliException e) {
77425       {
77426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77427       };
77428     } catch (...) {
77429       {
77430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77431       };
77432     }
77433   }
77434
77435   jresult = (void *)result;
77436   return jresult;
77437 }
77438
77439
77440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77441   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77442
77443   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77444   {
77445     try {
77446       delete arg1;
77447     } catch (std::out_of_range& e) {
77448       {
77449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77450       };
77451     } catch (std::exception& e) {
77452       {
77453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77454       };
77455     } catch (Dali::DaliException e) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77458       };
77459     } catch (...) {
77460       {
77461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77462       };
77463     }
77464   }
77465
77466 }
77467
77468
77469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77470   void * jresult ;
77471   Dali::Path arg1 ;
77472   Dali::Vector3 *arg2 = 0 ;
77473   Dali::Property::Index arg3 ;
77474   Dali::Vector3 *arg4 = 0 ;
77475   unsigned int arg5 ;
77476   Dali::Path *argp1 ;
77477   Dali::Toolkit::ScrollViewPagePathEffect result;
77478
77479   argp1 = (Dali::Path *)jarg1;
77480   if (!argp1) {
77481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77482     return 0;
77483   }
77484   arg1 = *argp1;
77485   arg2 = (Dali::Vector3 *)jarg2;
77486   if (!arg2) {
77487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77488     return 0;
77489   }
77490   arg3 = (Dali::Property::Index)jarg3;
77491   arg4 = (Dali::Vector3 *)jarg4;
77492   if (!arg4) {
77493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77494     return 0;
77495   }
77496   arg5 = (unsigned int)jarg5;
77497   {
77498     try {
77499       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77500     } catch (std::out_of_range& e) {
77501       {
77502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77503       };
77504     } catch (std::exception& e) {
77505       {
77506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77507       };
77508     } catch (Dali::DaliException e) {
77509       {
77510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77511       };
77512     } catch (...) {
77513       {
77514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77515       };
77516     }
77517   }
77518
77519   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77525   void * jresult ;
77526   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77527
77528   {
77529     try {
77530       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77531     } catch (std::out_of_range& e) {
77532       {
77533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77534       };
77535     } catch (std::exception& e) {
77536       {
77537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77538       };
77539     } catch (Dali::DaliException e) {
77540       {
77541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77542       };
77543     } catch (...) {
77544       {
77545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77546       };
77547     }
77548   }
77549
77550   jresult = (void *)result;
77551   return jresult;
77552 }
77553
77554
77555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77556   void * jresult ;
77557   Dali::BaseHandle arg1 ;
77558   Dali::BaseHandle *argp1 ;
77559   Dali::Toolkit::ScrollViewPagePathEffect result;
77560
77561   argp1 = (Dali::BaseHandle *)jarg1;
77562   if (!argp1) {
77563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77564     return 0;
77565   }
77566   arg1 = *argp1;
77567   {
77568     try {
77569       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77570     } catch (std::out_of_range& e) {
77571       {
77572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77573       };
77574     } catch (std::exception& e) {
77575       {
77576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77577       };
77578     } catch (Dali::DaliException e) {
77579       {
77580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77581       };
77582     } catch (...) {
77583       {
77584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77585       };
77586     }
77587   }
77588
77589   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77590   return jresult;
77591 }
77592
77593
77594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77595   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77596   Dali::Actor arg2 ;
77597   unsigned int arg3 ;
77598   Dali::Actor *argp2 ;
77599
77600   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77601   argp2 = (Dali::Actor *)jarg2;
77602   if (!argp2) {
77603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77604     return ;
77605   }
77606   arg2 = *argp2;
77607   arg3 = (unsigned int)jarg3;
77608   {
77609     try {
77610       (arg1)->ApplyToPage(arg2,arg3);
77611     } catch (std::out_of_range& e) {
77612       {
77613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77614       };
77615     } catch (std::exception& e) {
77616       {
77617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77618       };
77619     } catch (Dali::DaliException e) {
77620       {
77621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77622       };
77623     } catch (...) {
77624       {
77625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77626       };
77627     }
77628   }
77629
77630 }
77631
77632
77633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77634   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77635
77636   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77637   {
77638     try {
77639       delete arg1;
77640     } catch (std::out_of_range& e) {
77641       {
77642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77643       };
77644     } catch (std::exception& e) {
77645       {
77646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77647       };
77648     } catch (Dali::DaliException e) {
77649       {
77650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77651       };
77652     } catch (...) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77655       };
77656     }
77657   }
77658
77659 }
77660
77661
77662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77663   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77664   Dali::Toolkit::ClampState arg2 ;
77665
77666   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77667   arg2 = (Dali::Toolkit::ClampState)jarg2;
77668   if (arg1) (arg1)->x = arg2;
77669 }
77670
77671
77672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77673   int jresult ;
77674   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77675   Dali::Toolkit::ClampState result;
77676
77677   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77678   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77685   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77686   Dali::Toolkit::ClampState arg2 ;
77687
77688   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77689   arg2 = (Dali::Toolkit::ClampState)jarg2;
77690   if (arg1) (arg1)->y = arg2;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77695   int jresult ;
77696   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77697   Dali::Toolkit::ClampState result;
77698
77699   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77700   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77701   jresult = (int)result;
77702   return jresult;
77703 }
77704
77705
77706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77707   void * jresult ;
77708   Dali::Toolkit::ClampState2D *result = 0 ;
77709
77710   {
77711     try {
77712       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77713     } catch (std::out_of_range& e) {
77714       {
77715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77716       };
77717     } catch (std::exception& e) {
77718       {
77719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77720       };
77721     } catch (Dali::DaliException e) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77724       };
77725     } catch (...) {
77726       {
77727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77728       };
77729     }
77730   }
77731
77732   jresult = (void *)result;
77733   return jresult;
77734 }
77735
77736
77737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77738   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77739
77740   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77741   {
77742     try {
77743       delete arg1;
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77759       };
77760     }
77761   }
77762
77763 }
77764
77765
77766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77767   void * jresult ;
77768   float arg1 ;
77769   float arg2 ;
77770   bool arg3 ;
77771   Dali::Toolkit::RulerDomain *result = 0 ;
77772
77773   arg1 = (float)jarg1;
77774   arg2 = (float)jarg2;
77775   arg3 = jarg3 ? true : false;
77776   {
77777     try {
77778       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77779     } catch (std::out_of_range& e) {
77780       {
77781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77782       };
77783     } catch (std::exception& e) {
77784       {
77785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (Dali::DaliException e) {
77788       {
77789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77790       };
77791     } catch (...) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77794       };
77795     }
77796   }
77797
77798   jresult = (void *)result;
77799   return jresult;
77800 }
77801
77802
77803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77804   void * jresult ;
77805   float arg1 ;
77806   float arg2 ;
77807   Dali::Toolkit::RulerDomain *result = 0 ;
77808
77809   arg1 = (float)jarg1;
77810   arg2 = (float)jarg2;
77811   {
77812     try {
77813       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77814     } catch (std::out_of_range& e) {
77815       {
77816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77817       };
77818     } catch (std::exception& e) {
77819       {
77820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77821       };
77822     } catch (Dali::DaliException e) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77825       };
77826     } catch (...) {
77827       {
77828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77829       };
77830     }
77831   }
77832
77833   jresult = (void *)result;
77834   return jresult;
77835 }
77836
77837
77838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77839   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77840   float arg2 ;
77841
77842   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77843   arg2 = (float)jarg2;
77844   if (arg1) (arg1)->min = arg2;
77845 }
77846
77847
77848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77849   float jresult ;
77850   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77851   float result;
77852
77853   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77854   result = (float) ((arg1)->min);
77855   jresult = result;
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77861   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77862   float arg2 ;
77863
77864   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77865   arg2 = (float)jarg2;
77866   if (arg1) (arg1)->max = arg2;
77867 }
77868
77869
77870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77871   float jresult ;
77872   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77873   float result;
77874
77875   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77876   result = (float) ((arg1)->max);
77877   jresult = result;
77878   return jresult;
77879 }
77880
77881
77882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77883   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77884   bool arg2 ;
77885
77886   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77887   arg2 = jarg2 ? true : false;
77888   if (arg1) (arg1)->enabled = arg2;
77889 }
77890
77891
77892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77893   unsigned int jresult ;
77894   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77895   bool result;
77896
77897   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77898   result = (bool) ((arg1)->enabled);
77899   jresult = result;
77900   return jresult;
77901 }
77902
77903
77904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77905   float jresult ;
77906   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77907   float arg2 ;
77908   float arg3 ;
77909   float arg4 ;
77910   float result;
77911
77912   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77913   arg2 = (float)jarg2;
77914   arg3 = (float)jarg3;
77915   arg4 = (float)jarg4;
77916   {
77917     try {
77918       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77919     } catch (std::out_of_range& e) {
77920       {
77921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (std::exception& e) {
77924       {
77925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77926       };
77927     } catch (Dali::DaliException e) {
77928       {
77929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77930       };
77931     } catch (...) {
77932       {
77933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77934       };
77935     }
77936   }
77937
77938   jresult = result;
77939   return jresult;
77940 }
77941
77942
77943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77944   float jresult ;
77945   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77946   float arg2 ;
77947   float arg3 ;
77948   float result;
77949
77950   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77951   arg2 = (float)jarg2;
77952   arg3 = (float)jarg3;
77953   {
77954     try {
77955       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77956     } catch (std::out_of_range& e) {
77957       {
77958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77959       };
77960     } catch (std::exception& e) {
77961       {
77962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77963       };
77964     } catch (Dali::DaliException e) {
77965       {
77966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77967       };
77968     } catch (...) {
77969       {
77970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77971       };
77972     }
77973   }
77974
77975   jresult = result;
77976   return jresult;
77977 }
77978
77979
77980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77981   float jresult ;
77982   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77983   float arg2 ;
77984   float result;
77985
77986   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77987   arg2 = (float)jarg2;
77988   {
77989     try {
77990       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77991     } catch (std::out_of_range& e) {
77992       {
77993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (std::exception& e) {
77996       {
77997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77998       };
77999     } catch (Dali::DaliException e) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78002       };
78003     } catch (...) {
78004       {
78005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78006       };
78007     }
78008   }
78009
78010   jresult = result;
78011   return jresult;
78012 }
78013
78014
78015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78016   float jresult ;
78017   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78018   float arg2 ;
78019   float arg3 ;
78020   float arg4 ;
78021   Dali::Toolkit::ClampState *arg5 = 0 ;
78022   float result;
78023
78024   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78025   arg2 = (float)jarg2;
78026   arg3 = (float)jarg3;
78027   arg4 = (float)jarg4;
78028   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78029   if (!arg5) {
78030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78031     return 0;
78032   }
78033   {
78034     try {
78035       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78036     } catch (std::out_of_range& e) {
78037       {
78038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78039       };
78040     } catch (std::exception& e) {
78041       {
78042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78043       };
78044     } catch (Dali::DaliException e) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78047       };
78048     } catch (...) {
78049       {
78050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78051       };
78052     }
78053   }
78054
78055   jresult = result;
78056   return jresult;
78057 }
78058
78059
78060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78061   float jresult ;
78062   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78063   float result;
78064
78065   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78066   {
78067     try {
78068       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78069     } catch (std::out_of_range& e) {
78070       {
78071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78072       };
78073     } catch (std::exception& e) {
78074       {
78075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78076       };
78077     } catch (Dali::DaliException e) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78080       };
78081     } catch (...) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78084       };
78085     }
78086   }
78087
78088   jresult = result;
78089   return jresult;
78090 }
78091
78092
78093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78094   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78095
78096   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78097   {
78098     try {
78099       delete arg1;
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78107       };
78108     } catch (Dali::DaliException e) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78111       };
78112     } catch (...) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78115       };
78116     }
78117   }
78118
78119 }
78120
78121
78122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78123   float jresult ;
78124   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78125   float arg2 ;
78126   float arg3 ;
78127   float result;
78128
78129   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78130   arg2 = (float)jarg2;
78131   arg3 = (float)jarg3;
78132   {
78133     try {
78134       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78135     } catch (std::out_of_range& e) {
78136       {
78137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78138       };
78139     } catch (std::exception& e) {
78140       {
78141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78142       };
78143     } catch (Dali::DaliException e) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78146       };
78147     } catch (...) {
78148       {
78149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78150       };
78151     }
78152   }
78153
78154   jresult = result;
78155   return jresult;
78156 }
78157
78158
78159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78160   float jresult ;
78161   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78162   float arg2 ;
78163   float result;
78164
78165   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78166   arg2 = (float)jarg2;
78167   {
78168     try {
78169       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78170     } catch (std::out_of_range& e) {
78171       {
78172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78173       };
78174     } catch (std::exception& e) {
78175       {
78176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78177       };
78178     } catch (Dali::DaliException e) {
78179       {
78180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78181       };
78182     } catch (...) {
78183       {
78184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78185       };
78186     }
78187   }
78188
78189   jresult = result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78195   float jresult ;
78196   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78197   unsigned int arg2 ;
78198   unsigned int *arg3 = 0 ;
78199   bool arg4 ;
78200   float result;
78201
78202   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78203   arg2 = (unsigned int)jarg2;
78204   arg3 = (unsigned int *)jarg3;
78205   arg4 = jarg4 ? true : false;
78206   {
78207     try {
78208       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78209     } catch (std::out_of_range& e) {
78210       {
78211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78212       };
78213     } catch (std::exception& e) {
78214       {
78215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78216       };
78217     } catch (Dali::DaliException e) {
78218       {
78219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78220       };
78221     } catch (...) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78224       };
78225     }
78226   }
78227
78228   jresult = result;
78229   return jresult;
78230 }
78231
78232
78233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78234   unsigned int jresult ;
78235   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78236   float arg2 ;
78237   bool arg3 ;
78238   unsigned int result;
78239
78240   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78241   arg2 = (float)jarg2;
78242   arg3 = jarg3 ? true : false;
78243   {
78244     try {
78245       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78246     } catch (std::out_of_range& e) {
78247       {
78248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78249       };
78250     } catch (std::exception& e) {
78251       {
78252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78253       };
78254     } catch (Dali::DaliException e) {
78255       {
78256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78257       };
78258     } catch (...) {
78259       {
78260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78261       };
78262     }
78263   }
78264
78265   jresult = result;
78266   return jresult;
78267 }
78268
78269
78270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78271   unsigned int jresult ;
78272   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78273   unsigned int result;
78274
78275   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78276   {
78277     try {
78278       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78279     } catch (std::out_of_range& e) {
78280       {
78281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (std::exception& e) {
78284       {
78285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78286       };
78287     } catch (Dali::DaliException e) {
78288       {
78289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78290       };
78291     } catch (...) {
78292       {
78293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78294       };
78295     }
78296   }
78297
78298   jresult = result;
78299   return jresult;
78300 }
78301
78302
78303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78304   int jresult ;
78305   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78306   Dali::Toolkit::Ruler::RulerType result;
78307
78308   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78309   {
78310     try {
78311       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78312     } catch (std::out_of_range& e) {
78313       {
78314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (std::exception& e) {
78317       {
78318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78319       };
78320     } catch (Dali::DaliException e) {
78321       {
78322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78323       };
78324     } catch (...) {
78325       {
78326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78327       };
78328     }
78329   }
78330
78331   jresult = (int)result;
78332   return jresult;
78333 }
78334
78335
78336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78337   unsigned int jresult ;
78338   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78339   bool result;
78340
78341   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78342   {
78343     try {
78344       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78345     } catch (std::out_of_range& e) {
78346       {
78347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78348       };
78349     } catch (std::exception& e) {
78350       {
78351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78352       };
78353     } catch (Dali::DaliException e) {
78354       {
78355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78356       };
78357     } catch (...) {
78358       {
78359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78360       };
78361     }
78362   }
78363
78364   jresult = result;
78365   return jresult;
78366 }
78367
78368
78369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78370   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78371
78372   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78373   {
78374     try {
78375       (arg1)->Enable();
78376     } catch (std::out_of_range& e) {
78377       {
78378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78379       };
78380     } catch (std::exception& e) {
78381       {
78382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78383       };
78384     } catch (Dali::DaliException e) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78387       };
78388     } catch (...) {
78389       {
78390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78391       };
78392     }
78393   }
78394
78395 }
78396
78397
78398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78399   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78400
78401   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78402   {
78403     try {
78404       (arg1)->Disable();
78405     } catch (std::out_of_range& e) {
78406       {
78407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78408       };
78409     } catch (std::exception& e) {
78410       {
78411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78412       };
78413     } catch (Dali::DaliException e) {
78414       {
78415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78416       };
78417     } catch (...) {
78418       {
78419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78420       };
78421     }
78422   }
78423
78424 }
78425
78426
78427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78428   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78429   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78430   Dali::Toolkit::RulerDomain *argp2 ;
78431
78432   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78433   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78434   if (!argp2) {
78435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78436     return ;
78437   }
78438   arg2 = *argp2;
78439   {
78440     try {
78441       (arg1)->SetDomain(arg2);
78442     } catch (std::out_of_range& e) {
78443       {
78444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78445       };
78446     } catch (std::exception& e) {
78447       {
78448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78449       };
78450     } catch (Dali::DaliException e) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78453       };
78454     } catch (...) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78457       };
78458     }
78459   }
78460
78461 }
78462
78463
78464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78465   void * jresult ;
78466   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78467   Dali::Toolkit::RulerDomain *result = 0 ;
78468
78469   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78470   {
78471     try {
78472       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78473     } catch (std::out_of_range& e) {
78474       {
78475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (std::exception& e) {
78478       {
78479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78480       };
78481     } catch (Dali::DaliException e) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78484       };
78485     } catch (...) {
78486       {
78487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78488       };
78489     }
78490   }
78491
78492   jresult = (void *)result;
78493   return jresult;
78494 }
78495
78496
78497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78498   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78499
78500   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78501   {
78502     try {
78503       (arg1)->DisableDomain();
78504     } catch (std::out_of_range& e) {
78505       {
78506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78507       };
78508     } catch (std::exception& e) {
78509       {
78510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78511       };
78512     } catch (Dali::DaliException e) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78515       };
78516     } catch (...) {
78517       {
78518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78519       };
78520     }
78521   }
78522
78523 }
78524
78525
78526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78527   float jresult ;
78528   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78529   float arg2 ;
78530   float arg3 ;
78531   float arg4 ;
78532   float result;
78533
78534   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78535   arg2 = (float)jarg2;
78536   arg3 = (float)jarg3;
78537   arg4 = (float)jarg4;
78538   {
78539     try {
78540       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78541     } catch (std::out_of_range& e) {
78542       {
78543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78544       };
78545     } catch (std::exception& e) {
78546       {
78547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78548       };
78549     } catch (Dali::DaliException e) {
78550       {
78551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78552       };
78553     } catch (...) {
78554       {
78555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78556       };
78557     }
78558   }
78559
78560   jresult = result;
78561   return jresult;
78562 }
78563
78564
78565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78566   float jresult ;
78567   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78568   float arg2 ;
78569   float arg3 ;
78570   float result;
78571
78572   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78573   arg2 = (float)jarg2;
78574   arg3 = (float)jarg3;
78575   {
78576     try {
78577       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78578     } catch (std::out_of_range& e) {
78579       {
78580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (std::exception& e) {
78583       {
78584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78585       };
78586     } catch (Dali::DaliException e) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78589       };
78590     } catch (...) {
78591       {
78592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78593       };
78594     }
78595   }
78596
78597   jresult = result;
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78603   float jresult ;
78604   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78605   float arg2 ;
78606   float result;
78607
78608   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78609   arg2 = (float)jarg2;
78610   {
78611     try {
78612       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78613     } catch (std::out_of_range& e) {
78614       {
78615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78616       };
78617     } catch (std::exception& e) {
78618       {
78619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78620       };
78621     } catch (Dali::DaliException e) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78624       };
78625     } catch (...) {
78626       {
78627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78628       };
78629     }
78630   }
78631
78632   jresult = result;
78633   return jresult;
78634 }
78635
78636
78637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78638   float jresult ;
78639   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78640   float arg2 ;
78641   float arg3 ;
78642   float arg4 ;
78643   Dali::Toolkit::ClampState *arg5 = 0 ;
78644   float result;
78645
78646   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78647   arg2 = (float)jarg2;
78648   arg3 = (float)jarg3;
78649   arg4 = (float)jarg4;
78650   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78651   if (!arg5) {
78652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78653     return 0;
78654   }
78655   {
78656     try {
78657       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78658     } catch (std::out_of_range& e) {
78659       {
78660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78661       };
78662     } catch (std::exception& e) {
78663       {
78664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78665       };
78666     } catch (Dali::DaliException e) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78669       };
78670     } catch (...) {
78671       {
78672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78673       };
78674     }
78675   }
78676
78677   jresult = result;
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78683   float jresult ;
78684   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78685   float arg2 ;
78686   float arg3 ;
78687   float arg4 ;
78688   float arg5 ;
78689   float result;
78690
78691   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78692   arg2 = (float)jarg2;
78693   arg3 = (float)jarg3;
78694   arg4 = (float)jarg4;
78695   arg5 = (float)jarg5;
78696   {
78697     try {
78698       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78699     } catch (std::out_of_range& e) {
78700       {
78701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (std::exception& e) {
78704       {
78705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78706       };
78707     } catch (Dali::DaliException e) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78710       };
78711     } catch (...) {
78712       {
78713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78714       };
78715     }
78716   }
78717
78718   jresult = result;
78719   return jresult;
78720 }
78721
78722
78723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78724   float jresult ;
78725   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78726   float arg2 ;
78727   float arg3 ;
78728   float arg4 ;
78729   float result;
78730
78731   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78732   arg2 = (float)jarg2;
78733   arg3 = (float)jarg3;
78734   arg4 = (float)jarg4;
78735   {
78736     try {
78737       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78738     } catch (std::out_of_range& e) {
78739       {
78740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78741       };
78742     } catch (std::exception& e) {
78743       {
78744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78745       };
78746     } catch (Dali::DaliException e) {
78747       {
78748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78749       };
78750     } catch (...) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78753       };
78754     }
78755   }
78756
78757   jresult = result;
78758   return jresult;
78759 }
78760
78761
78762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78763   float jresult ;
78764   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78765   float arg2 ;
78766   float arg3 ;
78767   float result;
78768
78769   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78770   arg2 = (float)jarg2;
78771   arg3 = (float)jarg3;
78772   {
78773     try {
78774       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78775     } catch (std::out_of_range& e) {
78776       {
78777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (std::exception& e) {
78780       {
78781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78782       };
78783     } catch (Dali::DaliException e) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78790       };
78791     }
78792   }
78793
78794   jresult = result;
78795   return jresult;
78796 }
78797
78798
78799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78800   float jresult ;
78801   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78802   float arg2 ;
78803   float result;
78804
78805   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78806   arg2 = (float)jarg2;
78807   {
78808     try {
78809       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78810     } catch (std::out_of_range& e) {
78811       {
78812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (std::exception& e) {
78815       {
78816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78817       };
78818     } catch (Dali::DaliException e) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78821       };
78822     } catch (...) {
78823       {
78824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78825       };
78826     }
78827   }
78828
78829   jresult = result;
78830   return jresult;
78831 }
78832
78833
78834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78835   float jresult ;
78836   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78837   float arg2 ;
78838   float arg3 ;
78839   float arg4 ;
78840   float arg5 ;
78841   Dali::Toolkit::ClampState *arg6 = 0 ;
78842   float result;
78843
78844   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78845   arg2 = (float)jarg2;
78846   arg3 = (float)jarg3;
78847   arg4 = (float)jarg4;
78848   arg5 = (float)jarg5;
78849   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78850   if (!arg6) {
78851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78852     return 0;
78853   }
78854   {
78855     try {
78856       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78857     } catch (std::out_of_range& e) {
78858       {
78859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78860       };
78861     } catch (std::exception& e) {
78862       {
78863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78864       };
78865     } catch (Dali::DaliException e) {
78866       {
78867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78868       };
78869     } catch (...) {
78870       {
78871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78872       };
78873     }
78874   }
78875
78876   jresult = result;
78877   return jresult;
78878 }
78879
78880
78881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78882   void * jresult ;
78883   Dali::Toolkit::DefaultRuler *result = 0 ;
78884
78885   {
78886     try {
78887       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78888     } catch (std::out_of_range& e) {
78889       {
78890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78891       };
78892     } catch (std::exception& e) {
78893       {
78894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78895       };
78896     } catch (Dali::DaliException e) {
78897       {
78898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78899       };
78900     } catch (...) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78903       };
78904     }
78905   }
78906
78907   jresult = (void *)result;
78908   return jresult;
78909 }
78910
78911
78912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78913   float jresult ;
78914   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78915   float arg2 ;
78916   float arg3 ;
78917   float result;
78918
78919   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78920   arg2 = (float)jarg2;
78921   arg3 = (float)jarg3;
78922   {
78923     try {
78924       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78925     } catch (std::out_of_range& e) {
78926       {
78927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (std::exception& e) {
78930       {
78931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78932       };
78933     } catch (Dali::DaliException e) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78936       };
78937     } catch (...) {
78938       {
78939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78940       };
78941     }
78942   }
78943
78944   jresult = result;
78945   return jresult;
78946 }
78947
78948
78949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78950   float jresult ;
78951   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78952   unsigned int arg2 ;
78953   unsigned int *arg3 = 0 ;
78954   bool arg4 ;
78955   float result;
78956
78957   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78958   arg2 = (unsigned int)jarg2;
78959   arg3 = (unsigned int *)jarg3;
78960   arg4 = jarg4 ? true : false;
78961   {
78962     try {
78963       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78964     } catch (std::out_of_range& e) {
78965       {
78966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78967       };
78968     } catch (std::exception& e) {
78969       {
78970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78971       };
78972     } catch (Dali::DaliException e) {
78973       {
78974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78975       };
78976     } catch (...) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78979       };
78980     }
78981   }
78982
78983   jresult = result;
78984   return jresult;
78985 }
78986
78987
78988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78989   unsigned int jresult ;
78990   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78991   float arg2 ;
78992   bool arg3 ;
78993   unsigned int result;
78994
78995   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78996   arg2 = (float)jarg2;
78997   arg3 = jarg3 ? true : false;
78998   {
78999     try {
79000       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79001     } catch (std::out_of_range& e) {
79002       {
79003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79004       };
79005     } catch (std::exception& e) {
79006       {
79007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (Dali::DaliException e) {
79010       {
79011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79012       };
79013     } catch (...) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79016       };
79017     }
79018   }
79019
79020   jresult = result;
79021   return jresult;
79022 }
79023
79024
79025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79026   unsigned int jresult ;
79027   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79028   unsigned int result;
79029
79030   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79031   {
79032     try {
79033       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79034     } catch (std::out_of_range& e) {
79035       {
79036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (std::exception& e) {
79039       {
79040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79041       };
79042     } catch (Dali::DaliException e) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79045       };
79046     } catch (...) {
79047       {
79048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79049       };
79050     }
79051   }
79052
79053   jresult = result;
79054   return jresult;
79055 }
79056
79057
79058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79059   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79060
79061   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79062   {
79063     try {
79064       delete arg1;
79065     } catch (std::out_of_range& e) {
79066       {
79067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79068       };
79069     } catch (std::exception& e) {
79070       {
79071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79072       };
79073     } catch (Dali::DaliException e) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79076       };
79077     } catch (...) {
79078       {
79079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79080       };
79081     }
79082   }
79083
79084 }
79085
79086
79087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79088   void * jresult ;
79089   float arg1 ;
79090   Dali::Toolkit::FixedRuler *result = 0 ;
79091
79092   arg1 = (float)jarg1;
79093   {
79094     try {
79095       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79096     } catch (std::out_of_range& e) {
79097       {
79098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79099       };
79100     } catch (std::exception& e) {
79101       {
79102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79103       };
79104     } catch (Dali::DaliException e) {
79105       {
79106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79107       };
79108     } catch (...) {
79109       {
79110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79111       };
79112     }
79113   }
79114
79115   jresult = (void *)result;
79116   return jresult;
79117 }
79118
79119
79120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79121   void * jresult ;
79122   Dali::Toolkit::FixedRuler *result = 0 ;
79123
79124   {
79125     try {
79126       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79127     } catch (std::out_of_range& e) {
79128       {
79129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (std::exception& e) {
79132       {
79133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (Dali::DaliException e) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79142       };
79143     }
79144   }
79145
79146   jresult = (void *)result;
79147   return jresult;
79148 }
79149
79150
79151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79152   float jresult ;
79153   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79154   float arg2 ;
79155   float arg3 ;
79156   float result;
79157
79158   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79159   arg2 = (float)jarg2;
79160   arg3 = (float)jarg3;
79161   {
79162     try {
79163       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79164     } catch (std::out_of_range& e) {
79165       {
79166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79167       };
79168     } catch (std::exception& e) {
79169       {
79170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79171       };
79172     } catch (Dali::DaliException e) {
79173       {
79174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79175       };
79176     } catch (...) {
79177       {
79178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79179       };
79180     }
79181   }
79182
79183   jresult = result;
79184   return jresult;
79185 }
79186
79187
79188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79189   float jresult ;
79190   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79191   unsigned int arg2 ;
79192   unsigned int *arg3 = 0 ;
79193   bool arg4 ;
79194   float result;
79195
79196   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79197   arg2 = (unsigned int)jarg2;
79198   arg3 = (unsigned int *)jarg3;
79199   arg4 = jarg4 ? true : false;
79200   {
79201     try {
79202       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79203     } catch (std::out_of_range& e) {
79204       {
79205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79206       };
79207     } catch (std::exception& e) {
79208       {
79209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79210       };
79211     } catch (Dali::DaliException e) {
79212       {
79213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79214       };
79215     } catch (...) {
79216       {
79217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79218       };
79219     }
79220   }
79221
79222   jresult = result;
79223   return jresult;
79224 }
79225
79226
79227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79228   unsigned int jresult ;
79229   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79230   float arg2 ;
79231   bool arg3 ;
79232   unsigned int result;
79233
79234   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79235   arg2 = (float)jarg2;
79236   arg3 = jarg3 ? true : false;
79237   {
79238     try {
79239       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79240     } catch (std::out_of_range& e) {
79241       {
79242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79243       };
79244     } catch (std::exception& e) {
79245       {
79246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79247       };
79248     } catch (Dali::DaliException e) {
79249       {
79250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79251       };
79252     } catch (...) {
79253       {
79254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79255       };
79256     }
79257   }
79258
79259   jresult = result;
79260   return jresult;
79261 }
79262
79263
79264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79265   unsigned int jresult ;
79266   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79267   unsigned int result;
79268
79269   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79270   {
79271     try {
79272       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79273     } catch (std::out_of_range& e) {
79274       {
79275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79276       };
79277     } catch (std::exception& e) {
79278       {
79279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79280       };
79281     } catch (Dali::DaliException e) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79284       };
79285     } catch (...) {
79286       {
79287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79288       };
79289     }
79290   }
79291
79292   jresult = result;
79293   return jresult;
79294 }
79295
79296
79297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79298   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79299
79300   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79301   {
79302     try {
79303       delete arg1;
79304     } catch (std::out_of_range& e) {
79305       {
79306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79307       };
79308     } catch (std::exception& e) {
79309       {
79310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79311       };
79312     } catch (Dali::DaliException e) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79315       };
79316     } catch (...) {
79317       {
79318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79319       };
79320     }
79321   }
79322
79323 }
79324
79325
79326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79327   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79328   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79329
79330   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79331   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79332   if (arg1) (arg1)->scale = *arg2;
79333 }
79334
79335
79336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79337   void * jresult ;
79338   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79339   Dali::Toolkit::ClampState2D *result = 0 ;
79340
79341   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79342   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79343   jresult = (void *)result;
79344   return jresult;
79345 }
79346
79347
79348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79349   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79350   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79351
79352   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79353   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79354   if (arg1) (arg1)->position = *arg2;
79355 }
79356
79357
79358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79359   void * jresult ;
79360   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79361   Dali::Toolkit::ClampState2D *result = 0 ;
79362
79363   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79364   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79365   jresult = (void *)result;
79366   return jresult;
79367 }
79368
79369
79370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79371   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79372   Dali::Toolkit::ClampState arg2 ;
79373
79374   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79375   arg2 = (Dali::Toolkit::ClampState)jarg2;
79376   if (arg1) (arg1)->rotation = arg2;
79377 }
79378
79379
79380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79381   int jresult ;
79382   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79383   Dali::Toolkit::ClampState result;
79384
79385   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79386   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79387   jresult = (int)result;
79388   return jresult;
79389 }
79390
79391
79392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79393   void * jresult ;
79394   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79395
79396   {
79397     try {
79398       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79399     } catch (std::out_of_range& e) {
79400       {
79401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (std::exception& e) {
79404       {
79405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79406       };
79407     } catch (Dali::DaliException e) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79410       };
79411     } catch (...) {
79412       {
79413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79414       };
79415     }
79416   }
79417
79418   jresult = (void *)result;
79419   return jresult;
79420 }
79421
79422
79423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79424   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79425
79426   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79427   {
79428     try {
79429       delete arg1;
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79437       };
79438     } catch (Dali::DaliException e) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79445       };
79446     }
79447   }
79448
79449 }
79450
79451
79452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79453   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79454   Dali::Toolkit::SnapType arg2 ;
79455
79456   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79457   arg2 = (Dali::Toolkit::SnapType)jarg2;
79458   if (arg1) (arg1)->type = arg2;
79459 }
79460
79461
79462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79463   int jresult ;
79464   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79465   Dali::Toolkit::SnapType result;
79466
79467   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79468   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79469   jresult = (int)result;
79470   return jresult;
79471 }
79472
79473
79474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79475   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79476   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79477
79478   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79479   arg2 = (Dali::Vector2 *)jarg2;
79480   if (arg1) (arg1)->position = *arg2;
79481 }
79482
79483
79484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79485   void * jresult ;
79486   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79487   Dali::Vector2 *result = 0 ;
79488
79489   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79490   result = (Dali::Vector2 *)& ((arg1)->position);
79491   jresult = (void *)result;
79492   return jresult;
79493 }
79494
79495
79496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79497   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79498   float arg2 ;
79499
79500   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79501   arg2 = (float)jarg2;
79502   if (arg1) (arg1)->duration = arg2;
79503 }
79504
79505
79506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79507   float jresult ;
79508   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79509   float result;
79510
79511   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79512   result = (float) ((arg1)->duration);
79513   jresult = result;
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79519   void * jresult ;
79520   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79521
79522   {
79523     try {
79524       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79525     } catch (std::out_of_range& e) {
79526       {
79527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (std::exception& e) {
79530       {
79531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (Dali::DaliException e) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79536       };
79537     } catch (...) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79540       };
79541     }
79542   }
79543
79544   jresult = (void *)result;
79545   return jresult;
79546 }
79547
79548
79549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79550   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79551
79552   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79553   {
79554     try {
79555       delete arg1;
79556     } catch (std::out_of_range& e) {
79557       {
79558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79559       };
79560     } catch (std::exception& e) {
79561       {
79562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79563       };
79564     } catch (Dali::DaliException e) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79567       };
79568     } catch (...) {
79569       {
79570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79571       };
79572     }
79573   }
79574
79575 }
79576
79577
79578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79579   int jresult ;
79580   int result;
79581
79582   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79583   jresult = (int)result;
79584   return jresult;
79585 }
79586
79587
79588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79589   int jresult ;
79590   int result;
79591
79592   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79593   jresult = (int)result;
79594   return jresult;
79595 }
79596
79597
79598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79599   int jresult ;
79600   int result;
79601
79602   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79603   jresult = (int)result;
79604   return jresult;
79605 }
79606
79607
79608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79609   int jresult ;
79610   int result;
79611
79612   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79613   jresult = (int)result;
79614   return jresult;
79615 }
79616
79617
79618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79619   int jresult ;
79620   int result;
79621
79622   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79623   jresult = (int)result;
79624   return jresult;
79625 }
79626
79627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79628   int jresult ;
79629   int result;
79630
79631   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79632   jresult = (int)result;
79633   return jresult;
79634 }
79635
79636
79637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79638   int jresult ;
79639   int result;
79640
79641   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79642   jresult = (int)result;
79643   return jresult;
79644 }
79645
79646
79647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79648   int jresult ;
79649   int result;
79650
79651   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79652   jresult = (int)result;
79653   return jresult;
79654 }
79655
79656
79657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79658   int jresult ;
79659   int result;
79660
79661   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79662   jresult = (int)result;
79663   return jresult;
79664 }
79665
79666
79667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79668   int jresult ;
79669   int result;
79670
79671   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79672   jresult = (int)result;
79673   return jresult;
79674 }
79675
79676
79677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79678   int jresult ;
79679   int result;
79680
79681   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79682   jresult = (int)result;
79683   return jresult;
79684 }
79685
79686
79687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79688   int jresult ;
79689   int result;
79690
79691   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79692   jresult = (int)result;
79693   return jresult;
79694 }
79695
79696
79697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79698   int jresult ;
79699   int result;
79700
79701   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79702   jresult = (int)result;
79703   return jresult;
79704 }
79705
79706
79707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79708   int jresult ;
79709   int result;
79710
79711   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79712   jresult = (int)result;
79713   return jresult;
79714 }
79715
79716
79717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79718   int jresult ;
79719   int result;
79720
79721   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79722   jresult = (int)result;
79723   return jresult;
79724 }
79725
79726
79727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79728   int jresult ;
79729   int result;
79730
79731   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79732   jresult = (int)result;
79733   return jresult;
79734 }
79735
79736
79737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79738   int jresult ;
79739   int result;
79740
79741   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79742   jresult = (int)result;
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79748   int jresult ;
79749   int result;
79750
79751   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79752   jresult = (int)result;
79753   return jresult;
79754 }
79755
79756
79757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79758   int jresult ;
79759   int result;
79760
79761   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79762   jresult = (int)result;
79763   return jresult;
79764 }
79765
79766
79767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79768   int jresult ;
79769   int result;
79770
79771   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79772   jresult = (int)result;
79773   return jresult;
79774 }
79775
79776
79777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79778   int jresult ;
79779   int result;
79780
79781   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79782   jresult = (int)result;
79783   return jresult;
79784 }
79785
79786
79787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79788   int jresult ;
79789   int result;
79790
79791   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79792   jresult = (int)result;
79793   return jresult;
79794 }
79795
79796
79797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79798   int jresult ;
79799   int result;
79800
79801   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79802   jresult = (int)result;
79803   return jresult;
79804 }
79805
79806
79807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79808   int jresult ;
79809   int result;
79810
79811   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79812   jresult = (int)result;
79813   return jresult;
79814 }
79815
79816
79817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79818   int jresult ;
79819   int result;
79820
79821   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79822   jresult = (int)result;
79823   return jresult;
79824 }
79825
79826
79827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79828   int jresult ;
79829   int result;
79830
79831   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79832   jresult = (int)result;
79833   return jresult;
79834 }
79835
79836
79837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79838   void * jresult ;
79839   Dali::Toolkit::ScrollView::Property *result = 0 ;
79840
79841   {
79842     try {
79843       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79844     } catch (std::out_of_range& e) {
79845       {
79846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (std::exception& e) {
79849       {
79850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79851       };
79852     } catch (Dali::DaliException e) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79855       };
79856     } catch (...) {
79857       {
79858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79859       };
79860     }
79861   }
79862
79863   jresult = (void *)result;
79864   return jresult;
79865 }
79866
79867
79868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79869   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79870
79871   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79872   {
79873     try {
79874       delete arg1;
79875     } catch (std::out_of_range& e) {
79876       {
79877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79878       };
79879     } catch (std::exception& e) {
79880       {
79881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79882       };
79883     } catch (Dali::DaliException e) {
79884       {
79885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79886       };
79887     } catch (...) {
79888       {
79889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79890       };
79891     }
79892   }
79893
79894 }
79895
79896
79897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79898   void * jresult ;
79899   Dali::Toolkit::ScrollView *result = 0 ;
79900
79901   {
79902     try {
79903       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79904     } catch (std::out_of_range& e) {
79905       {
79906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79907       };
79908     } catch (std::exception& e) {
79909       {
79910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79911       };
79912     } catch (Dali::DaliException e) {
79913       {
79914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79915       };
79916     } catch (...) {
79917       {
79918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79919       };
79920     }
79921   }
79922
79923   jresult = (void *)result;
79924   return jresult;
79925 }
79926
79927
79928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79929   void * jresult ;
79930   Dali::Toolkit::ScrollView *arg1 = 0 ;
79931   Dali::Toolkit::ScrollView *result = 0 ;
79932
79933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79934   if (!arg1) {
79935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79936     return 0;
79937   }
79938   {
79939     try {
79940       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (Dali::DaliException e) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79952       };
79953     } catch (...) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79956       };
79957     }
79958   }
79959
79960   jresult = (void *)result;
79961   return jresult;
79962 }
79963
79964
79965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79966   void * jresult ;
79967   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79968   Dali::Toolkit::ScrollView *arg2 = 0 ;
79969   Dali::Toolkit::ScrollView *result = 0 ;
79970
79971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79972   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79973   if (!arg2) {
79974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79975     return 0;
79976   }
79977   {
79978     try {
79979       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79980     } catch (std::out_of_range& e) {
79981       {
79982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79983       };
79984     } catch (std::exception& e) {
79985       {
79986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79987       };
79988     } catch (Dali::DaliException e) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79991       };
79992     } catch (...) {
79993       {
79994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79995       };
79996     }
79997   }
79998
79999   jresult = (void *)result;
80000   return jresult;
80001 }
80002
80003
80004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80006
80007   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80008   {
80009     try {
80010       delete arg1;
80011     } catch (std::out_of_range& e) {
80012       {
80013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80014       };
80015     } catch (std::exception& e) {
80016       {
80017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80018       };
80019     } catch (Dali::DaliException e) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80022       };
80023     } catch (...) {
80024       {
80025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80026       };
80027     }
80028   }
80029
80030 }
80031
80032
80033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80034   void * jresult ;
80035   Dali::Toolkit::ScrollView result;
80036
80037   {
80038     try {
80039       result = Dali::Toolkit::ScrollView::New();
80040     } catch (std::out_of_range& e) {
80041       {
80042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80043       };
80044     } catch (std::exception& e) {
80045       {
80046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80047       };
80048     } catch (Dali::DaliException e) {
80049       {
80050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80051       };
80052     } catch (...) {
80053       {
80054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80055       };
80056     }
80057   }
80058
80059   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80060   return jresult;
80061 }
80062
80063
80064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80065   void * jresult ;
80066   Dali::BaseHandle arg1 ;
80067   Dali::BaseHandle *argp1 ;
80068   Dali::Toolkit::ScrollView result;
80069
80070   argp1 = (Dali::BaseHandle *)jarg1;
80071   if (!argp1) {
80072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80073     return 0;
80074   }
80075   arg1 = *argp1;
80076   {
80077     try {
80078       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80079     } catch (std::out_of_range& e) {
80080       {
80081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80082       };
80083     } catch (std::exception& e) {
80084       {
80085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80086       };
80087     } catch (Dali::DaliException e) {
80088       {
80089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80090       };
80091     } catch (...) {
80092       {
80093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80094       };
80095     }
80096   }
80097
80098   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80099   return jresult;
80100 }
80101
80102
80103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80104   void * jresult ;
80105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80106   Dali::AlphaFunction result;
80107
80108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80109   {
80110     try {
80111       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80112     } catch (std::out_of_range& e) {
80113       {
80114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80115       };
80116     } catch (std::exception& e) {
80117       {
80118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80119       };
80120     } catch (Dali::DaliException e) {
80121       {
80122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80123       };
80124     } catch (...) {
80125       {
80126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80127       };
80128     }
80129   }
80130
80131   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80132   return jresult;
80133 }
80134
80135
80136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80138   Dali::AlphaFunction arg2 ;
80139   Dali::AlphaFunction *argp2 ;
80140
80141   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80142   argp2 = (Dali::AlphaFunction *)jarg2;
80143   if (!argp2) {
80144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80145     return ;
80146   }
80147   arg2 = *argp2;
80148   {
80149     try {
80150       (arg1)->SetScrollSnapAlphaFunction(arg2);
80151     } catch (std::out_of_range& e) {
80152       {
80153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (std::exception& e) {
80156       {
80157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80158       };
80159     } catch (Dali::DaliException e) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80162       };
80163     } catch (...) {
80164       {
80165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80166       };
80167     }
80168   }
80169
80170 }
80171
80172
80173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80174   void * jresult ;
80175   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80176   Dali::AlphaFunction result;
80177
80178   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80179   {
80180     try {
80181       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80182     } catch (std::out_of_range& e) {
80183       {
80184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80185       };
80186     } catch (std::exception& e) {
80187       {
80188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80189       };
80190     } catch (Dali::DaliException e) {
80191       {
80192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80193       };
80194     } catch (...) {
80195       {
80196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80197       };
80198     }
80199   }
80200
80201   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80202   return jresult;
80203 }
80204
80205
80206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80208   Dali::AlphaFunction arg2 ;
80209   Dali::AlphaFunction *argp2 ;
80210
80211   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80212   argp2 = (Dali::AlphaFunction *)jarg2;
80213   if (!argp2) {
80214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80215     return ;
80216   }
80217   arg2 = *argp2;
80218   {
80219     try {
80220       (arg1)->SetScrollFlickAlphaFunction(arg2);
80221     } catch (std::out_of_range& e) {
80222       {
80223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80224       };
80225     } catch (std::exception& e) {
80226       {
80227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80228       };
80229     } catch (Dali::DaliException e) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80232       };
80233     } catch (...) {
80234       {
80235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80236       };
80237     }
80238   }
80239
80240 }
80241
80242
80243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80244   float jresult ;
80245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80246   float result;
80247
80248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80249   {
80250     try {
80251       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80252     } catch (std::out_of_range& e) {
80253       {
80254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80255       };
80256     } catch (std::exception& e) {
80257       {
80258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80259       };
80260     } catch (Dali::DaliException e) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80263       };
80264     } catch (...) {
80265       {
80266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80267       };
80268     }
80269   }
80270
80271   jresult = result;
80272   return jresult;
80273 }
80274
80275
80276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80277   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80278   float arg2 ;
80279
80280   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80281   arg2 = (float)jarg2;
80282   {
80283     try {
80284       (arg1)->SetScrollSnapDuration(arg2);
80285     } catch (std::out_of_range& e) {
80286       {
80287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80288       };
80289     } catch (std::exception& e) {
80290       {
80291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (Dali::DaliException e) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80296       };
80297     } catch (...) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80300       };
80301     }
80302   }
80303
80304 }
80305
80306
80307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80308   float jresult ;
80309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80310   float result;
80311
80312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80313   {
80314     try {
80315       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80316     } catch (std::out_of_range& e) {
80317       {
80318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80319       };
80320     } catch (std::exception& e) {
80321       {
80322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80323       };
80324     } catch (Dali::DaliException e) {
80325       {
80326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80327       };
80328     } catch (...) {
80329       {
80330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80331       };
80332     }
80333   }
80334
80335   jresult = result;
80336   return jresult;
80337 }
80338
80339
80340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80342   float arg2 ;
80343
80344   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80345   arg2 = (float)jarg2;
80346   {
80347     try {
80348       (arg1)->SetScrollFlickDuration(arg2);
80349     } catch (std::out_of_range& e) {
80350       {
80351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80352       };
80353     } catch (std::exception& e) {
80354       {
80355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80356       };
80357     } catch (Dali::DaliException e) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80360       };
80361     } catch (...) {
80362       {
80363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80364       };
80365     }
80366   }
80367
80368 }
80369
80370
80371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80372   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80373   Dali::Toolkit::RulerPtr arg2 ;
80374   Dali::Toolkit::RulerPtr *argp2 ;
80375
80376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80377   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80378   if (!argp2) {
80379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80380     return ;
80381   }
80382   arg2 = *argp2;
80383   {
80384     try {
80385       (arg1)->SetRulerX(arg2);
80386     } catch (std::out_of_range& e) {
80387       {
80388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80389       };
80390     } catch (std::exception& e) {
80391       {
80392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80393       };
80394     } catch (Dali::DaliException e) {
80395       {
80396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80397       };
80398     } catch (...) {
80399       {
80400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80401       };
80402     }
80403   }
80404
80405 }
80406
80407
80408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80410   Dali::Toolkit::RulerPtr arg2 ;
80411   Dali::Toolkit::RulerPtr *argp2 ;
80412
80413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80414   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80415   if (!argp2) {
80416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80417     return ;
80418   }
80419   arg2 = *argp2;
80420   {
80421     try {
80422       (arg1)->SetRulerY(arg2);
80423     } catch (std::out_of_range& e) {
80424       {
80425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (std::exception& e) {
80428       {
80429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80430       };
80431     } catch (Dali::DaliException e) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80434       };
80435     } catch (...) {
80436       {
80437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80438       };
80439     }
80440   }
80441
80442 }
80443
80444
80445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80447   bool arg2 ;
80448
80449   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80450   arg2 = jarg2 ? true : false;
80451   {
80452     try {
80453       (arg1)->SetScrollSensitive(arg2);
80454     } catch (std::out_of_range& e) {
80455       {
80456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80457       };
80458     } catch (std::exception& e) {
80459       {
80460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80461       };
80462     } catch (Dali::DaliException e) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80465       };
80466     } catch (...) {
80467       {
80468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80469       };
80470     }
80471   }
80472
80473 }
80474
80475
80476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80478   float arg2 ;
80479   float arg3 ;
80480
80481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80482   arg2 = (float)jarg2;
80483   arg3 = (float)jarg3;
80484   {
80485     try {
80486       (arg1)->SetMaxOvershoot(arg2,arg3);
80487     } catch (std::out_of_range& e) {
80488       {
80489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80490       };
80491     } catch (std::exception& e) {
80492       {
80493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80494       };
80495     } catch (Dali::DaliException e) {
80496       {
80497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80498       };
80499     } catch (...) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80502       };
80503     }
80504   }
80505
80506 }
80507
80508
80509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80510   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80511   Dali::AlphaFunction arg2 ;
80512   Dali::AlphaFunction *argp2 ;
80513
80514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80515   argp2 = (Dali::AlphaFunction *)jarg2;
80516   if (!argp2) {
80517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80518     return ;
80519   }
80520   arg2 = *argp2;
80521   {
80522     try {
80523       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80524     } catch (std::out_of_range& e) {
80525       {
80526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80527       };
80528     } catch (std::exception& e) {
80529       {
80530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80531       };
80532     } catch (Dali::DaliException e) {
80533       {
80534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80535       };
80536     } catch (...) {
80537       {
80538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80539       };
80540     }
80541   }
80542
80543 }
80544
80545
80546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80548   float arg2 ;
80549
80550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80551   arg2 = (float)jarg2;
80552   {
80553     try {
80554       (arg1)->SetSnapOvershootDuration(arg2);
80555     } catch (std::out_of_range& e) {
80556       {
80557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (std::exception& e) {
80560       {
80561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80562       };
80563     } catch (Dali::DaliException e) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80566       };
80567     } catch (...) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80570       };
80571     }
80572   }
80573
80574 }
80575
80576
80577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80579   bool arg2 ;
80580
80581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80582   arg2 = jarg2 ? true : false;
80583   {
80584     try {
80585       (arg1)->SetActorAutoSnap(arg2);
80586     } catch (std::out_of_range& e) {
80587       {
80588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80589       };
80590     } catch (std::exception& e) {
80591       {
80592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80593       };
80594     } catch (Dali::DaliException e) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80597       };
80598     } catch (...) {
80599       {
80600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80601       };
80602     }
80603   }
80604
80605 }
80606
80607
80608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80610   bool arg2 ;
80611
80612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80613   arg2 = jarg2 ? true : false;
80614   {
80615     try {
80616       (arg1)->SetWrapMode(arg2);
80617     } catch (std::out_of_range& e) {
80618       {
80619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80620       };
80621     } catch (std::exception& e) {
80622       {
80623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80624       };
80625     } catch (Dali::DaliException e) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80628       };
80629     } catch (...) {
80630       {
80631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80632       };
80633     }
80634   }
80635
80636 }
80637
80638
80639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80640   int jresult ;
80641   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80642   int result;
80643
80644   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80645   {
80646     try {
80647       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80648     } catch (std::out_of_range& e) {
80649       {
80650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80651       };
80652     } catch (std::exception& e) {
80653       {
80654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80655       };
80656     } catch (Dali::DaliException e) {
80657       {
80658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80659       };
80660     } catch (...) {
80661       {
80662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80663       };
80664     }
80665   }
80666
80667   jresult = result;
80668   return jresult;
80669 }
80670
80671
80672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80673   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80674   int arg2 ;
80675
80676   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80677   arg2 = (int)jarg2;
80678   {
80679     try {
80680       (arg1)->SetScrollUpdateDistance(arg2);
80681     } catch (std::out_of_range& e) {
80682       {
80683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80684       };
80685     } catch (std::exception& e) {
80686       {
80687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80688       };
80689     } catch (Dali::DaliException e) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80692       };
80693     } catch (...) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80696       };
80697     }
80698   }
80699
80700 }
80701
80702
80703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80704   unsigned int jresult ;
80705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80706   bool result;
80707
80708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80709   {
80710     try {
80711       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80712     } catch (std::out_of_range& e) {
80713       {
80714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80715       };
80716     } catch (std::exception& e) {
80717       {
80718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (Dali::DaliException e) {
80721       {
80722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80727       };
80728     }
80729   }
80730
80731   jresult = result;
80732   return jresult;
80733 }
80734
80735
80736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80738   bool arg2 ;
80739
80740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80741   arg2 = jarg2 ? true : false;
80742   {
80743     try {
80744       (arg1)->SetAxisAutoLock(arg2);
80745     } catch (std::out_of_range& e) {
80746       {
80747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80748       };
80749     } catch (std::exception& e) {
80750       {
80751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80752       };
80753     } catch (Dali::DaliException e) {
80754       {
80755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80756       };
80757     } catch (...) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80760       };
80761     }
80762   }
80763
80764 }
80765
80766
80767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80768   float jresult ;
80769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80770   float result;
80771
80772   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80773   {
80774     try {
80775       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80776     } catch (std::out_of_range& e) {
80777       {
80778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (std::exception& e) {
80781       {
80782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80783       };
80784     } catch (Dali::DaliException e) {
80785       {
80786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80787       };
80788     } catch (...) {
80789       {
80790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80791       };
80792     }
80793   }
80794
80795   jresult = result;
80796   return jresult;
80797 }
80798
80799
80800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80802   float arg2 ;
80803
80804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80805   arg2 = (float)jarg2;
80806   {
80807     try {
80808       (arg1)->SetAxisAutoLockGradient(arg2);
80809     } catch (std::out_of_range& e) {
80810       {
80811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80812       };
80813     } catch (std::exception& e) {
80814       {
80815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80816       };
80817     } catch (Dali::DaliException e) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80820       };
80821     } catch (...) {
80822       {
80823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80824       };
80825     }
80826   }
80827
80828 }
80829
80830
80831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80832   float jresult ;
80833   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80834   float result;
80835
80836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80837   {
80838     try {
80839       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80840     } catch (std::out_of_range& e) {
80841       {
80842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80843       };
80844     } catch (std::exception& e) {
80845       {
80846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80847       };
80848     } catch (Dali::DaliException e) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80851       };
80852     } catch (...) {
80853       {
80854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80855       };
80856     }
80857   }
80858
80859   jresult = result;
80860   return jresult;
80861 }
80862
80863
80864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80866   float arg2 ;
80867
80868   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80869   arg2 = (float)jarg2;
80870   {
80871     try {
80872       (arg1)->SetFrictionCoefficient(arg2);
80873     } catch (std::out_of_range& e) {
80874       {
80875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80876       };
80877     } catch (std::exception& e) {
80878       {
80879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80880       };
80881     } catch (Dali::DaliException e) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80884       };
80885     } catch (...) {
80886       {
80887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80888       };
80889     }
80890   }
80891
80892 }
80893
80894
80895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80896   float jresult ;
80897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80898   float result;
80899
80900   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80901   {
80902     try {
80903       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80904     } catch (std::out_of_range& e) {
80905       {
80906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80907       };
80908     } catch (std::exception& e) {
80909       {
80910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80911       };
80912     } catch (Dali::DaliException e) {
80913       {
80914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80915       };
80916     } catch (...) {
80917       {
80918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80919       };
80920     }
80921   }
80922
80923   jresult = result;
80924   return jresult;
80925 }
80926
80927
80928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80929   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80930   float arg2 ;
80931
80932   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80933   arg2 = (float)jarg2;
80934   {
80935     try {
80936       (arg1)->SetFlickSpeedCoefficient(arg2);
80937     } catch (std::out_of_range& e) {
80938       {
80939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80940       };
80941     } catch (std::exception& e) {
80942       {
80943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80944       };
80945     } catch (Dali::DaliException e) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80948       };
80949     } catch (...) {
80950       {
80951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80952       };
80953     }
80954   }
80955
80956 }
80957
80958
80959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80960   void * jresult ;
80961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80962   Dali::Vector2 result;
80963
80964   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80965   {
80966     try {
80967       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80968     } catch (std::out_of_range& e) {
80969       {
80970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80971       };
80972     } catch (std::exception& e) {
80973       {
80974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80975       };
80976     } catch (Dali::DaliException e) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80979       };
80980     } catch (...) {
80981       {
80982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80983       };
80984     }
80985   }
80986
80987   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80988   return jresult;
80989 }
80990
80991
80992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80994   Dali::Vector2 *arg2 = 0 ;
80995
80996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80997   arg2 = (Dali::Vector2 *)jarg2;
80998   if (!arg2) {
80999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81000     return ;
81001   }
81002   {
81003     try {
81004       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81005     } catch (std::out_of_range& e) {
81006       {
81007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81008       };
81009     } catch (std::exception& e) {
81010       {
81011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81012       };
81013     } catch (Dali::DaliException e) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81016       };
81017     } catch (...) {
81018       {
81019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81020       };
81021     }
81022   }
81023
81024 }
81025
81026
81027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81028   float jresult ;
81029   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81030   float result;
81031
81032   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81033   {
81034     try {
81035       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81036     } catch (std::out_of_range& e) {
81037       {
81038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (std::exception& e) {
81041       {
81042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81043       };
81044     } catch (Dali::DaliException e) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81047       };
81048     } catch (...) {
81049       {
81050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81051       };
81052     }
81053   }
81054
81055   jresult = result;
81056   return jresult;
81057 }
81058
81059
81060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81061   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81062   float arg2 ;
81063
81064   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81065   arg2 = (float)jarg2;
81066   {
81067     try {
81068       (arg1)->SetMinimumSpeedForFlick(arg2);
81069     } catch (std::out_of_range& e) {
81070       {
81071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81072       };
81073     } catch (std::exception& e) {
81074       {
81075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81076       };
81077     } catch (Dali::DaliException e) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81080       };
81081     } catch (...) {
81082       {
81083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81084       };
81085     }
81086   }
81087
81088 }
81089
81090
81091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81092   float jresult ;
81093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81094   float result;
81095
81096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81097   {
81098     try {
81099       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81100     } catch (std::out_of_range& e) {
81101       {
81102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81103       };
81104     } catch (std::exception& e) {
81105       {
81106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81107       };
81108     } catch (Dali::DaliException e) {
81109       {
81110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81111       };
81112     } catch (...) {
81113       {
81114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81115       };
81116     }
81117   }
81118
81119   jresult = result;
81120   return jresult;
81121 }
81122
81123
81124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81125   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81126   float arg2 ;
81127
81128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81129   arg2 = (float)jarg2;
81130   {
81131     try {
81132       (arg1)->SetMaxFlickSpeed(arg2);
81133     } catch (std::out_of_range& e) {
81134       {
81135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81136       };
81137     } catch (std::exception& e) {
81138       {
81139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81140       };
81141     } catch (Dali::DaliException e) {
81142       {
81143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81144       };
81145     } catch (...) {
81146       {
81147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81148       };
81149     }
81150   }
81151
81152 }
81153
81154
81155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81156   void * jresult ;
81157   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81158   Dali::Vector2 result;
81159
81160   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81161   {
81162     try {
81163       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81164     } catch (std::out_of_range& e) {
81165       {
81166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (std::exception& e) {
81169       {
81170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81171       };
81172     } catch (Dali::DaliException e) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81175       };
81176     } catch (...) {
81177       {
81178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81179       };
81180     }
81181   }
81182
81183   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81189   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81190   Dali::Vector2 arg2 ;
81191   Dali::Vector2 *argp2 ;
81192
81193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81194   argp2 = (Dali::Vector2 *)jarg2;
81195   if (!argp2) {
81196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81197     return ;
81198   }
81199   arg2 = *argp2;
81200   {
81201     try {
81202       (arg1)->SetWheelScrollDistanceStep(arg2);
81203     } catch (std::out_of_range& e) {
81204       {
81205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81206       };
81207     } catch (std::exception& e) {
81208       {
81209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81210       };
81211     } catch (Dali::DaliException e) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81214       };
81215     } catch (...) {
81216       {
81217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81218       };
81219     }
81220   }
81221
81222 }
81223
81224
81225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81226   void * jresult ;
81227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81228   Dali::Vector2 result;
81229
81230   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81231   {
81232     try {
81233       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81234     } catch (std::out_of_range& e) {
81235       {
81236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81237       };
81238     } catch (std::exception& e) {
81239       {
81240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81241       };
81242     } catch (Dali::DaliException e) {
81243       {
81244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81245       };
81246     } catch (...) {
81247       {
81248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81249       };
81250     }
81251   }
81252
81253   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81254   return jresult;
81255 }
81256
81257
81258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81259   unsigned int jresult ;
81260   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81261   unsigned int result;
81262
81263   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81264   {
81265     try {
81266       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81267     } catch (std::out_of_range& e) {
81268       {
81269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (std::exception& e) {
81272       {
81273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81274       };
81275     } catch (Dali::DaliException e) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81278       };
81279     } catch (...) {
81280       {
81281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81282       };
81283     }
81284   }
81285
81286   jresult = result;
81287   return jresult;
81288 }
81289
81290
81291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81292   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81293   Dali::Vector2 *arg2 = 0 ;
81294
81295   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81296   arg2 = (Dali::Vector2 *)jarg2;
81297   if (!arg2) {
81298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81299     return ;
81300   }
81301   {
81302     try {
81303       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81311       };
81312     } catch (Dali::DaliException e) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81319       };
81320     }
81321   }
81322
81323 }
81324
81325
81326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81328   Dali::Vector2 *arg2 = 0 ;
81329   float arg3 ;
81330
81331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81332   arg2 = (Dali::Vector2 *)jarg2;
81333   if (!arg2) {
81334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81335     return ;
81336   }
81337   arg3 = (float)jarg3;
81338   {
81339     try {
81340       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81341     } catch (std::out_of_range& e) {
81342       {
81343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (std::exception& e) {
81346       {
81347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81348       };
81349     } catch (Dali::DaliException e) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81352       };
81353     } catch (...) {
81354       {
81355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81356       };
81357     }
81358   }
81359
81360 }
81361
81362
81363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81364   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81365   Dali::Vector2 *arg2 = 0 ;
81366   float arg3 ;
81367   Dali::AlphaFunction arg4 ;
81368   Dali::AlphaFunction *argp4 ;
81369
81370   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81371   arg2 = (Dali::Vector2 *)jarg2;
81372   if (!arg2) {
81373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81374     return ;
81375   }
81376   arg3 = (float)jarg3;
81377   argp4 = (Dali::AlphaFunction *)jarg4;
81378   if (!argp4) {
81379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81380     return ;
81381   }
81382   arg4 = *argp4;
81383   {
81384     try {
81385       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81393       };
81394     } catch (Dali::DaliException e) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81397       };
81398     } catch (...) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81401       };
81402     }
81403   }
81404
81405 }
81406
81407
81408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81410   Dali::Vector2 *arg2 = 0 ;
81411   float arg3 ;
81412   Dali::Toolkit::DirectionBias arg4 ;
81413   Dali::Toolkit::DirectionBias arg5 ;
81414
81415   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81416   arg2 = (Dali::Vector2 *)jarg2;
81417   if (!arg2) {
81418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81419     return ;
81420   }
81421   arg3 = (float)jarg3;
81422   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81423   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81424   {
81425     try {
81426       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81427     } catch (std::out_of_range& e) {
81428       {
81429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81430       };
81431     } catch (std::exception& e) {
81432       {
81433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81434       };
81435     } catch (Dali::DaliException e) {
81436       {
81437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81438       };
81439     } catch (...) {
81440       {
81441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81442       };
81443     }
81444   }
81445
81446 }
81447
81448
81449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81450   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81451   Dali::Vector2 *arg2 = 0 ;
81452   float arg3 ;
81453   Dali::AlphaFunction arg4 ;
81454   Dali::Toolkit::DirectionBias arg5 ;
81455   Dali::Toolkit::DirectionBias arg6 ;
81456   Dali::AlphaFunction *argp4 ;
81457
81458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81459   arg2 = (Dali::Vector2 *)jarg2;
81460   if (!arg2) {
81461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81462     return ;
81463   }
81464   arg3 = (float)jarg3;
81465   argp4 = (Dali::AlphaFunction *)jarg4;
81466   if (!argp4) {
81467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81468     return ;
81469   }
81470   arg4 = *argp4;
81471   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81472   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81473   {
81474     try {
81475       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81491       };
81492     }
81493   }
81494
81495 }
81496
81497
81498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81500   unsigned int arg2 ;
81501
81502   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81503   arg2 = (unsigned int)jarg2;
81504   {
81505     try {
81506       (arg1)->ScrollTo(arg2);
81507     } catch (std::out_of_range& e) {
81508       {
81509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81510       };
81511     } catch (std::exception& e) {
81512       {
81513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81514       };
81515     } catch (Dali::DaliException e) {
81516       {
81517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81518       };
81519     } catch (...) {
81520       {
81521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81522       };
81523     }
81524   }
81525
81526 }
81527
81528
81529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81531   unsigned int arg2 ;
81532   float arg3 ;
81533
81534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81535   arg2 = (unsigned int)jarg2;
81536   arg3 = (float)jarg3;
81537   {
81538     try {
81539       (arg1)->ScrollTo(arg2,arg3);
81540     } catch (std::out_of_range& e) {
81541       {
81542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (std::exception& e) {
81545       {
81546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81547       };
81548     } catch (Dali::DaliException e) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81551       };
81552     } catch (...) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81555       };
81556     }
81557   }
81558
81559 }
81560
81561
81562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81564   unsigned int arg2 ;
81565   float arg3 ;
81566   Dali::Toolkit::DirectionBias arg4 ;
81567
81568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81569   arg2 = (unsigned int)jarg2;
81570   arg3 = (float)jarg3;
81571   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81572   {
81573     try {
81574       (arg1)->ScrollTo(arg2,arg3,arg4);
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81590       };
81591     }
81592   }
81593
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81599   Dali::Actor *arg2 = 0 ;
81600
81601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81602   arg2 = (Dali::Actor *)jarg2;
81603   if (!arg2) {
81604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81605     return ;
81606   }
81607   {
81608     try {
81609       (arg1)->ScrollTo(*arg2);
81610     } catch (std::out_of_range& e) {
81611       {
81612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (std::exception& e) {
81615       {
81616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81617       };
81618     } catch (Dali::DaliException e) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81621       };
81622     } catch (...) {
81623       {
81624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81625       };
81626     }
81627   }
81628
81629 }
81630
81631
81632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81633   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81634   Dali::Actor *arg2 = 0 ;
81635   float arg3 ;
81636
81637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81638   arg2 = (Dali::Actor *)jarg2;
81639   if (!arg2) {
81640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81641     return ;
81642   }
81643   arg3 = (float)jarg3;
81644   {
81645     try {
81646       (arg1)->ScrollTo(*arg2,arg3);
81647     } catch (std::out_of_range& e) {
81648       {
81649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81650       };
81651     } catch (std::exception& e) {
81652       {
81653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81654       };
81655     } catch (Dali::DaliException e) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81658       };
81659     } catch (...) {
81660       {
81661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81662       };
81663     }
81664   }
81665
81666 }
81667
81668
81669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81670   unsigned int jresult ;
81671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81672   bool result;
81673
81674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81675   {
81676     try {
81677       result = (bool)(arg1)->ScrollToSnapPoint();
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81685       };
81686     } catch (Dali::DaliException e) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81693       };
81694     }
81695   }
81696
81697   jresult = result;
81698   return jresult;
81699 }
81700
81701
81702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81704   Dali::Constraint arg2 ;
81705   Dali::Constraint *argp2 ;
81706
81707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81708   argp2 = (Dali::Constraint *)jarg2;
81709   if (!argp2) {
81710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81711     return ;
81712   }
81713   arg2 = *argp2;
81714   {
81715     try {
81716       (arg1)->ApplyConstraintToChildren(arg2);
81717     } catch (std::out_of_range& e) {
81718       {
81719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (std::exception& e) {
81722       {
81723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81724       };
81725     } catch (Dali::DaliException e) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81728       };
81729     } catch (...) {
81730       {
81731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81732       };
81733     }
81734   }
81735
81736 }
81737
81738
81739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81740   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81741
81742   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81743   {
81744     try {
81745       (arg1)->RemoveConstraintsFromChildren();
81746     } catch (std::out_of_range& e) {
81747       {
81748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81749       };
81750     } catch (std::exception& e) {
81751       {
81752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81753       };
81754     } catch (Dali::DaliException e) {
81755       {
81756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81757       };
81758     } catch (...) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81761       };
81762     }
81763   }
81764
81765 }
81766
81767
81768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81770   Dali::Toolkit::ScrollViewEffect arg2 ;
81771   Dali::Toolkit::ScrollViewEffect *argp2 ;
81772
81773   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81774   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81775   if (!argp2) {
81776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81777     return ;
81778   }
81779   arg2 = *argp2;
81780   {
81781     try {
81782       (arg1)->ApplyEffect(arg2);
81783     } catch (std::out_of_range& e) {
81784       {
81785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81786       };
81787     } catch (std::exception& e) {
81788       {
81789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81790       };
81791     } catch (Dali::DaliException e) {
81792       {
81793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81794       };
81795     } catch (...) {
81796       {
81797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81798       };
81799     }
81800   }
81801
81802 }
81803
81804
81805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81807   Dali::Toolkit::ScrollViewEffect arg2 ;
81808   Dali::Toolkit::ScrollViewEffect *argp2 ;
81809
81810   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81811   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81812   if (!argp2) {
81813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81814     return ;
81815   }
81816   arg2 = *argp2;
81817   {
81818     try {
81819       (arg1)->RemoveEffect(arg2);
81820     } catch (std::out_of_range& e) {
81821       {
81822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81823       };
81824     } catch (std::exception& e) {
81825       {
81826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81827       };
81828     } catch (Dali::DaliException e) {
81829       {
81830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81831       };
81832     } catch (...) {
81833       {
81834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81835       };
81836     }
81837   }
81838
81839 }
81840
81841
81842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81843   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81844
81845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81846   {
81847     try {
81848       (arg1)->RemoveAllEffects();
81849     } catch (std::out_of_range& e) {
81850       {
81851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (std::exception& e) {
81854       {
81855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81856       };
81857     } catch (Dali::DaliException e) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81860       };
81861     } catch (...) {
81862       {
81863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81864       };
81865     }
81866   }
81867
81868 }
81869
81870
81871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81872   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81873   Dali::Actor arg2 ;
81874   Dali::Actor *argp2 ;
81875
81876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81877   argp2 = (Dali::Actor *)jarg2;
81878   if (!argp2) {
81879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81880     return ;
81881   }
81882   arg2 = *argp2;
81883   {
81884     try {
81885       (arg1)->BindActor(arg2);
81886     } catch (std::out_of_range& e) {
81887       {
81888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81889       };
81890     } catch (std::exception& e) {
81891       {
81892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81893       };
81894     } catch (Dali::DaliException e) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81901       };
81902     }
81903   }
81904
81905 }
81906
81907
81908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81910   Dali::Actor arg2 ;
81911   Dali::Actor *argp2 ;
81912
81913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81914   argp2 = (Dali::Actor *)jarg2;
81915   if (!argp2) {
81916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81917     return ;
81918   }
81919   arg2 = *argp2;
81920   {
81921     try {
81922       (arg1)->UnbindActor(arg2);
81923     } catch (std::out_of_range& e) {
81924       {
81925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (std::exception& e) {
81928       {
81929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81930       };
81931     } catch (Dali::DaliException e) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81938       };
81939     }
81940   }
81941
81942 }
81943
81944
81945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81947   Dali::Radian arg2 ;
81948   Dali::Radian arg3 ;
81949   Dali::Radian *argp2 ;
81950   Dali::Radian *argp3 ;
81951
81952   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81953   argp2 = (Dali::Radian *)jarg2;
81954   if (!argp2) {
81955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81956     return ;
81957   }
81958   arg2 = *argp2;
81959   argp3 = (Dali::Radian *)jarg3;
81960   if (!argp3) {
81961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81962     return ;
81963   }
81964   arg3 = *argp3;
81965   {
81966     try {
81967       (arg1)->SetScrollingDirection(arg2,arg3);
81968     } catch (std::out_of_range& e) {
81969       {
81970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81971       };
81972     } catch (std::exception& e) {
81973       {
81974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81975       };
81976     } catch (Dali::DaliException e) {
81977       {
81978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81979       };
81980     } catch (...) {
81981       {
81982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81983       };
81984     }
81985   }
81986
81987 }
81988
81989
81990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81992   Dali::Radian arg2 ;
81993   Dali::Radian *argp2 ;
81994
81995   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81996   argp2 = (Dali::Radian *)jarg2;
81997   if (!argp2) {
81998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81999     return ;
82000   }
82001   arg2 = *argp2;
82002   {
82003     try {
82004       (arg1)->SetScrollingDirection(arg2);
82005     } catch (std::out_of_range& e) {
82006       {
82007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82008       };
82009     } catch (std::exception& e) {
82010       {
82011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82012       };
82013     } catch (Dali::DaliException e) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82016       };
82017     } catch (...) {
82018       {
82019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82020       };
82021     }
82022   }
82023
82024 }
82025
82026
82027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82029   Dali::Radian arg2 ;
82030   Dali::Radian *argp2 ;
82031
82032   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82033   argp2 = (Dali::Radian *)jarg2;
82034   if (!argp2) {
82035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82036     return ;
82037   }
82038   arg2 = *argp2;
82039   {
82040     try {
82041       (arg1)->RemoveScrollingDirection(arg2);
82042     } catch (std::out_of_range& e) {
82043       {
82044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (std::exception& e) {
82047       {
82048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82049       };
82050     } catch (Dali::DaliException e) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82053       };
82054     } catch (...) {
82055       {
82056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82057       };
82058     }
82059   }
82060
82061 }
82062
82063
82064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82065   void * jresult ;
82066   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82067   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82068
82069   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82070   {
82071     try {
82072       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82073     } catch (std::out_of_range& e) {
82074       {
82075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (std::exception& e) {
82078       {
82079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (Dali::DaliException e) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82088       };
82089     }
82090   }
82091
82092   jresult = (void *)result;
82093   return jresult;
82094 }
82095
82096
82097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82098   int jresult ;
82099   int result;
82100
82101   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82102   jresult = (int)result;
82103   return jresult;
82104 }
82105
82106
82107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82108   int jresult ;
82109   int result;
82110
82111   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82112   jresult = (int)result;
82113   return jresult;
82114 }
82115
82116
82117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82118   int jresult ;
82119   int result;
82120
82121   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82122   jresult = (int)result;
82123   return jresult;
82124 }
82125
82126
82127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82128   int jresult ;
82129   int result;
82130
82131   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82132   jresult = (int)result;
82133   return jresult;
82134 }
82135
82136
82137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82138   int jresult ;
82139   int result;
82140
82141   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82142   jresult = (int)result;
82143   return jresult;
82144 }
82145
82146
82147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82148   void * jresult ;
82149   Dali::Toolkit::TableView::Property *result = 0 ;
82150
82151   {
82152     try {
82153       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82154     } catch (std::out_of_range& e) {
82155       {
82156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (std::exception& e) {
82159       {
82160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82161       };
82162     } catch (Dali::DaliException e) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82165       };
82166     } catch (...) {
82167       {
82168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82169       };
82170     }
82171   }
82172
82173   jresult = (void *)result;
82174   return jresult;
82175 }
82176
82177
82178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82179   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82180
82181   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82182   {
82183     try {
82184       delete arg1;
82185     } catch (std::out_of_range& e) {
82186       {
82187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82188       };
82189     } catch (std::exception& e) {
82190       {
82191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82192       };
82193     } catch (Dali::DaliException e) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82196       };
82197     } catch (...) {
82198       {
82199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82200       };
82201     }
82202   }
82203
82204 }
82205
82206
82207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82208   int jresult ;
82209   int result;
82210
82211   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82212   jresult = (int)result;
82213   return jresult;
82214 }
82215
82216
82217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82218   int jresult ;
82219   int result;
82220
82221   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82222   jresult = (int)result;
82223   return jresult;
82224 }
82225
82226
82227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82228   int jresult ;
82229   int result;
82230
82231   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82232   jresult = (int)result;
82233   return jresult;
82234 }
82235
82236
82237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82238   int jresult ;
82239   int result;
82240
82241   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82242   jresult = (int)result;
82243   return jresult;
82244 }
82245
82246
82247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82248   int jresult ;
82249   int result;
82250
82251   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82252   jresult = (int)result;
82253   return jresult;
82254 }
82255
82256
82257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82258   void * jresult ;
82259   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82260
82261   {
82262     try {
82263       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82264     } catch (std::out_of_range& e) {
82265       {
82266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82267       };
82268     } catch (std::exception& e) {
82269       {
82270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82271       };
82272     } catch (Dali::DaliException e) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82275       };
82276     } catch (...) {
82277       {
82278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82279       };
82280     }
82281   }
82282
82283   jresult = (void *)result;
82284   return jresult;
82285 }
82286
82287
82288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82289   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82290
82291   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82292   {
82293     try {
82294       delete arg1;
82295     } catch (std::out_of_range& e) {
82296       {
82297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (std::exception& e) {
82300       {
82301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (Dali::DaliException e) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313
82314 }
82315
82316
82317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82318   void * jresult ;
82319   unsigned int arg1 ;
82320   unsigned int arg2 ;
82321   unsigned int arg3 ;
82322   unsigned int arg4 ;
82323   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82324
82325   arg1 = (unsigned int)jarg1;
82326   arg2 = (unsigned int)jarg2;
82327   arg3 = (unsigned int)jarg3;
82328   arg4 = (unsigned int)jarg4;
82329   {
82330     try {
82331       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82332     } catch (std::out_of_range& e) {
82333       {
82334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82335       };
82336     } catch (std::exception& e) {
82337       {
82338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82339       };
82340     } catch (Dali::DaliException e) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82343       };
82344     } catch (...) {
82345       {
82346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82347       };
82348     }
82349   }
82350
82351   jresult = (void *)result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82357   void * jresult ;
82358   unsigned int arg1 ;
82359   unsigned int arg2 ;
82360   unsigned int arg3 ;
82361   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82362
82363   arg1 = (unsigned int)jarg1;
82364   arg2 = (unsigned int)jarg2;
82365   arg3 = (unsigned int)jarg3;
82366   {
82367     try {
82368       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82369     } catch (std::out_of_range& e) {
82370       {
82371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82372       };
82373     } catch (std::exception& e) {
82374       {
82375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82376       };
82377     } catch (Dali::DaliException e) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82380       };
82381     } catch (...) {
82382       {
82383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82384       };
82385     }
82386   }
82387
82388   jresult = (void *)result;
82389   return jresult;
82390 }
82391
82392
82393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82394   void * jresult ;
82395   unsigned int arg1 ;
82396   unsigned int arg2 ;
82397   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82398
82399   arg1 = (unsigned int)jarg1;
82400   arg2 = (unsigned int)jarg2;
82401   {
82402     try {
82403       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82404     } catch (std::out_of_range& e) {
82405       {
82406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (std::exception& e) {
82409       {
82410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (Dali::DaliException e) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82415       };
82416     } catch (...) {
82417       {
82418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82419       };
82420     }
82421   }
82422
82423   jresult = (void *)result;
82424   return jresult;
82425 }
82426
82427
82428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82429   void * jresult ;
82430   unsigned int arg1 ;
82431   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82432
82433   arg1 = (unsigned int)jarg1;
82434   {
82435     try {
82436       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82437     } catch (std::out_of_range& e) {
82438       {
82439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82440       };
82441     } catch (std::exception& e) {
82442       {
82443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82444       };
82445     } catch (Dali::DaliException e) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82448       };
82449     } catch (...) {
82450       {
82451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82452       };
82453     }
82454   }
82455
82456   jresult = (void *)result;
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82462   void * jresult ;
82463   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82464
82465   {
82466     try {
82467       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82468     } catch (std::out_of_range& e) {
82469       {
82470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (std::exception& e) {
82473       {
82474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82475       };
82476     } catch (Dali::DaliException e) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82479       };
82480     } catch (...) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82483       };
82484     }
82485   }
82486
82487   jresult = (void *)result;
82488   return jresult;
82489 }
82490
82491
82492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82493   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82494   unsigned int arg2 ;
82495
82496   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82497   arg2 = (unsigned int)jarg2;
82498   if (arg1) (arg1)->rowIndex = arg2;
82499 }
82500
82501
82502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82503   unsigned int jresult ;
82504   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82505   unsigned int result;
82506
82507   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82508   result = (unsigned int) ((arg1)->rowIndex);
82509   jresult = result;
82510   return jresult;
82511 }
82512
82513
82514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82515   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82516   unsigned int arg2 ;
82517
82518   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82519   arg2 = (unsigned int)jarg2;
82520   if (arg1) (arg1)->columnIndex = arg2;
82521 }
82522
82523
82524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82525   unsigned int jresult ;
82526   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82527   unsigned int result;
82528
82529   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82530   result = (unsigned int) ((arg1)->columnIndex);
82531   jresult = result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82537   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82538   unsigned int arg2 ;
82539
82540   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82541   arg2 = (unsigned int)jarg2;
82542   if (arg1) (arg1)->rowSpan = arg2;
82543 }
82544
82545
82546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82547   unsigned int jresult ;
82548   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82549   unsigned int result;
82550
82551   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82552   result = (unsigned int) ((arg1)->rowSpan);
82553   jresult = result;
82554   return jresult;
82555 }
82556
82557
82558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82559   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82560   unsigned int arg2 ;
82561
82562   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82563   arg2 = (unsigned int)jarg2;
82564   if (arg1) (arg1)->columnSpan = arg2;
82565 }
82566
82567
82568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82569   unsigned int jresult ;
82570   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82571   unsigned int result;
82572
82573   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82574   result = (unsigned int) ((arg1)->columnSpan);
82575   jresult = result;
82576   return jresult;
82577 }
82578
82579
82580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82581   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82582
82583   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82584   {
82585     try {
82586       delete arg1;
82587     } catch (std::out_of_range& e) {
82588       {
82589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82590       };
82591     } catch (std::exception& e) {
82592       {
82593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82594       };
82595     } catch (Dali::DaliException e) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82598       };
82599     } catch (...) {
82600       {
82601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82602       };
82603     }
82604   }
82605
82606 }
82607
82608
82609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82610   void * jresult ;
82611   Dali::Toolkit::TableView *result = 0 ;
82612
82613   {
82614     try {
82615       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82616     } catch (std::out_of_range& e) {
82617       {
82618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82619       };
82620     } catch (std::exception& e) {
82621       {
82622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82623       };
82624     } catch (Dali::DaliException e) {
82625       {
82626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82627       };
82628     } catch (...) {
82629       {
82630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82631       };
82632     }
82633   }
82634
82635   jresult = (void *)result;
82636   return jresult;
82637 }
82638
82639
82640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82641   void * jresult ;
82642   Dali::Toolkit::TableView *arg1 = 0 ;
82643   Dali::Toolkit::TableView *result = 0 ;
82644
82645   arg1 = (Dali::Toolkit::TableView *)jarg1;
82646   if (!arg1) {
82647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82648     return 0;
82649   }
82650   {
82651     try {
82652       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82653     } catch (std::out_of_range& e) {
82654       {
82655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (std::exception& e) {
82658       {
82659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82660       };
82661     } catch (Dali::DaliException e) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82664       };
82665     } catch (...) {
82666       {
82667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82668       };
82669     }
82670   }
82671
82672   jresult = (void *)result;
82673   return jresult;
82674 }
82675
82676
82677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82678   void * jresult ;
82679   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82680   Dali::Toolkit::TableView *arg2 = 0 ;
82681   Dali::Toolkit::TableView *result = 0 ;
82682
82683   arg1 = (Dali::Toolkit::TableView *)jarg1;
82684   arg2 = (Dali::Toolkit::TableView *)jarg2;
82685   if (!arg2) {
82686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82687     return 0;
82688   }
82689   {
82690     try {
82691       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82692     } catch (std::out_of_range& e) {
82693       {
82694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82695       };
82696     } catch (std::exception& e) {
82697       {
82698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82699       };
82700     } catch (Dali::DaliException e) {
82701       {
82702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82703       };
82704     } catch (...) {
82705       {
82706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82707       };
82708     }
82709   }
82710
82711   jresult = (void *)result;
82712   return jresult;
82713 }
82714
82715
82716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82717   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82718
82719   arg1 = (Dali::Toolkit::TableView *)jarg1;
82720   {
82721     try {
82722       delete arg1;
82723     } catch (std::out_of_range& e) {
82724       {
82725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82726       };
82727     } catch (std::exception& e) {
82728       {
82729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82730       };
82731     } catch (Dali::DaliException e) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82734       };
82735     } catch (...) {
82736       {
82737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82738       };
82739     }
82740   }
82741
82742 }
82743
82744
82745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82746   void * jresult ;
82747   unsigned int arg1 ;
82748   unsigned int arg2 ;
82749   Dali::Toolkit::TableView result;
82750
82751   arg1 = (unsigned int)jarg1;
82752   arg2 = (unsigned int)jarg2;
82753   {
82754     try {
82755       result = Dali::Toolkit::TableView::New(arg1,arg2);
82756     } catch (std::out_of_range& e) {
82757       {
82758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82759       };
82760     } catch (std::exception& e) {
82761       {
82762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82763       };
82764     } catch (Dali::DaliException e) {
82765       {
82766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82767       };
82768     } catch (...) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82771       };
82772     }
82773   }
82774
82775   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82776   return jresult;
82777 }
82778
82779
82780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82781   void * jresult ;
82782   Dali::BaseHandle arg1 ;
82783   Dali::BaseHandle *argp1 ;
82784   Dali::Toolkit::TableView result;
82785
82786   argp1 = (Dali::BaseHandle *)jarg1;
82787   if (!argp1) {
82788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82789     return 0;
82790   }
82791   arg1 = *argp1;
82792   {
82793     try {
82794       result = Dali::Toolkit::TableView::DownCast(arg1);
82795     } catch (std::out_of_range& e) {
82796       {
82797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (std::exception& e) {
82800       {
82801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82802       };
82803     } catch (Dali::DaliException e) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82806       };
82807     } catch (...) {
82808       {
82809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82810       };
82811     }
82812   }
82813
82814   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82815   return jresult;
82816 }
82817
82818
82819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82820   unsigned int jresult ;
82821   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82822   Dali::Actor arg2 ;
82823   Dali::Toolkit::TableView::CellPosition arg3 ;
82824   Dali::Actor *argp2 ;
82825   Dali::Toolkit::TableView::CellPosition *argp3 ;
82826   bool result;
82827
82828   arg1 = (Dali::Toolkit::TableView *)jarg1;
82829   argp2 = (Dali::Actor *)jarg2;
82830   if (!argp2) {
82831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82832     return 0;
82833   }
82834   arg2 = *argp2;
82835   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82836   if (!argp3) {
82837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82838     return 0;
82839   }
82840   arg3 = *argp3;
82841   {
82842     try {
82843       result = (bool)(arg1)->AddChild(arg2,arg3);
82844     } catch (std::out_of_range& e) {
82845       {
82846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82847       };
82848     } catch (std::exception& e) {
82849       {
82850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82851       };
82852     } catch (Dali::DaliException e) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82855       };
82856     } catch (...) {
82857       {
82858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82859       };
82860     }
82861   }
82862
82863   jresult = result;
82864   return jresult;
82865 }
82866
82867
82868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82869   void * jresult ;
82870   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82871   Dali::Toolkit::TableView::CellPosition arg2 ;
82872   Dali::Toolkit::TableView::CellPosition *argp2 ;
82873   Dali::Actor result;
82874
82875   arg1 = (Dali::Toolkit::TableView *)jarg1;
82876   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82877   if (!argp2) {
82878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82879     return 0;
82880   }
82881   arg2 = *argp2;
82882   {
82883     try {
82884       result = (arg1)->GetChildAt(arg2);
82885     } catch (std::out_of_range& e) {
82886       {
82887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (std::exception& e) {
82890       {
82891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82892       };
82893     } catch (Dali::DaliException e) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82896       };
82897     } catch (...) {
82898       {
82899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82900       };
82901     }
82902   }
82903
82904   jresult = new Dali::Actor((const Dali::Actor &)result);
82905   return jresult;
82906 }
82907
82908
82909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82910   void * jresult ;
82911   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82912   Dali::Toolkit::TableView::CellPosition arg2 ;
82913   Dali::Toolkit::TableView::CellPosition *argp2 ;
82914   Dali::Actor result;
82915
82916   arg1 = (Dali::Toolkit::TableView *)jarg1;
82917   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82918   if (!argp2) {
82919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82920     return 0;
82921   }
82922   arg2 = *argp2;
82923   {
82924     try {
82925       result = (arg1)->RemoveChildAt(arg2);
82926     } catch (std::out_of_range& e) {
82927       {
82928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82929       };
82930     } catch (std::exception& e) {
82931       {
82932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82933       };
82934     } catch (Dali::DaliException e) {
82935       {
82936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82937       };
82938     } catch (...) {
82939       {
82940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82941       };
82942     }
82943   }
82944
82945   jresult = new Dali::Actor((const Dali::Actor &)result);
82946   return jresult;
82947 }
82948
82949
82950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82951   unsigned int jresult ;
82952   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82953   Dali::Actor arg2 ;
82954   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82955   Dali::Actor *argp2 ;
82956   bool result;
82957
82958   arg1 = (Dali::Toolkit::TableView *)jarg1;
82959   argp2 = (Dali::Actor *)jarg2;
82960   if (!argp2) {
82961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82962     return 0;
82963   }
82964   arg2 = *argp2;
82965   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82966   if (!arg3) {
82967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82968     return 0;
82969   }
82970   {
82971     try {
82972       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82973     } catch (std::out_of_range& e) {
82974       {
82975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82976       };
82977     } catch (std::exception& e) {
82978       {
82979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82980       };
82981     } catch (Dali::DaliException e) {
82982       {
82983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82984       };
82985     } catch (...) {
82986       {
82987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82988       };
82989     }
82990   }
82991
82992   jresult = result;
82993   return jresult;
82994 }
82995
82996
82997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82998   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82999   unsigned int arg2 ;
83000
83001   arg1 = (Dali::Toolkit::TableView *)jarg1;
83002   arg2 = (unsigned int)jarg2;
83003   {
83004     try {
83005       (arg1)->InsertRow(arg2);
83006     } catch (std::out_of_range& e) {
83007       {
83008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (std::exception& e) {
83011       {
83012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83013       };
83014     } catch (Dali::DaliException e) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83017       };
83018     } catch (...) {
83019       {
83020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83021       };
83022     }
83023   }
83024
83025 }
83026
83027
83028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83029   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83030   unsigned int arg2 ;
83031
83032   arg1 = (Dali::Toolkit::TableView *)jarg1;
83033   arg2 = (unsigned int)jarg2;
83034   {
83035     try {
83036       (arg1)->DeleteRow(arg2);
83037     } catch (std::out_of_range& e) {
83038       {
83039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83040       };
83041     } catch (std::exception& e) {
83042       {
83043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83044       };
83045     } catch (Dali::DaliException e) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83048       };
83049     } catch (...) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83052       };
83053     }
83054   }
83055
83056 }
83057
83058
83059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83060   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83061   unsigned int arg2 ;
83062   std::vector< Dali::Actor > *arg3 = 0 ;
83063
83064   arg1 = (Dali::Toolkit::TableView *)jarg1;
83065   arg2 = (unsigned int)jarg2;
83066   arg3 = (std::vector< Dali::Actor > *)jarg3;
83067   if (!arg3) {
83068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83069     return ;
83070   }
83071   {
83072     try {
83073       (arg1)->DeleteRow(arg2,*arg3);
83074     } catch (std::out_of_range& e) {
83075       {
83076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83077       };
83078     } catch (std::exception& e) {
83079       {
83080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83081       };
83082     } catch (Dali::DaliException e) {
83083       {
83084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83085       };
83086     } catch (...) {
83087       {
83088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83089       };
83090     }
83091   }
83092
83093 }
83094
83095
83096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83097   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83098   unsigned int arg2 ;
83099
83100   arg1 = (Dali::Toolkit::TableView *)jarg1;
83101   arg2 = (unsigned int)jarg2;
83102   {
83103     try {
83104       (arg1)->InsertColumn(arg2);
83105     } catch (std::out_of_range& e) {
83106       {
83107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (std::exception& e) {
83110       {
83111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83112       };
83113     } catch (Dali::DaliException e) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83120       };
83121     }
83122   }
83123
83124 }
83125
83126
83127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83129   unsigned int arg2 ;
83130
83131   arg1 = (Dali::Toolkit::TableView *)jarg1;
83132   arg2 = (unsigned int)jarg2;
83133   {
83134     try {
83135       (arg1)->DeleteColumn(arg2);
83136     } catch (std::out_of_range& e) {
83137       {
83138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83139       };
83140     } catch (std::exception& e) {
83141       {
83142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83143       };
83144     } catch (Dali::DaliException e) {
83145       {
83146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83147       };
83148     } catch (...) {
83149       {
83150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83151       };
83152     }
83153   }
83154
83155 }
83156
83157
83158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83159   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83160   unsigned int arg2 ;
83161   std::vector< Dali::Actor > *arg3 = 0 ;
83162
83163   arg1 = (Dali::Toolkit::TableView *)jarg1;
83164   arg2 = (unsigned int)jarg2;
83165   arg3 = (std::vector< Dali::Actor > *)jarg3;
83166   if (!arg3) {
83167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83168     return ;
83169   }
83170   {
83171     try {
83172       (arg1)->DeleteColumn(arg2,*arg3);
83173     } catch (std::out_of_range& e) {
83174       {
83175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83176       };
83177     } catch (std::exception& e) {
83178       {
83179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83180       };
83181     } catch (Dali::DaliException e) {
83182       {
83183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83184       };
83185     } catch (...) {
83186       {
83187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83188       };
83189     }
83190   }
83191
83192 }
83193
83194
83195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83196   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83197   unsigned int arg2 ;
83198   unsigned int arg3 ;
83199
83200   arg1 = (Dali::Toolkit::TableView *)jarg1;
83201   arg2 = (unsigned int)jarg2;
83202   arg3 = (unsigned int)jarg3;
83203   {
83204     try {
83205       (arg1)->Resize(arg2,arg3);
83206     } catch (std::out_of_range& e) {
83207       {
83208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83209       };
83210     } catch (std::exception& e) {
83211       {
83212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83213       };
83214     } catch (Dali::DaliException e) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83217       };
83218     } catch (...) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83221       };
83222     }
83223   }
83224
83225 }
83226
83227
83228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83229   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83230   unsigned int arg2 ;
83231   unsigned int arg3 ;
83232   std::vector< Dali::Actor > *arg4 = 0 ;
83233
83234   arg1 = (Dali::Toolkit::TableView *)jarg1;
83235   arg2 = (unsigned int)jarg2;
83236   arg3 = (unsigned int)jarg3;
83237   arg4 = (std::vector< Dali::Actor > *)jarg4;
83238   if (!arg4) {
83239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83240     return ;
83241   }
83242   {
83243     try {
83244       (arg1)->Resize(arg2,arg3,*arg4);
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83252       };
83253     } catch (Dali::DaliException e) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83260       };
83261     }
83262   }
83263
83264 }
83265
83266
83267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83268   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83269   Dali::Size arg2 ;
83270   Dali::Size *argp2 ;
83271
83272   arg1 = (Dali::Toolkit::TableView *)jarg1;
83273   argp2 = (Dali::Size *)jarg2;
83274   if (!argp2) {
83275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83276     return ;
83277   }
83278   arg2 = *argp2;
83279   {
83280     try {
83281       (arg1)->SetCellPadding(arg2);
83282     } catch (std::out_of_range& e) {
83283       {
83284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83285       };
83286     } catch (std::exception& e) {
83287       {
83288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83289       };
83290     } catch (Dali::DaliException e) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83293       };
83294     } catch (...) {
83295       {
83296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83297       };
83298     }
83299   }
83300
83301 }
83302
83303
83304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83305   void * jresult ;
83306   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83307   Dali::Size result;
83308
83309   arg1 = (Dali::Toolkit::TableView *)jarg1;
83310   {
83311     try {
83312       result = (arg1)->GetCellPadding();
83313     } catch (std::out_of_range& e) {
83314       {
83315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (std::exception& e) {
83318       {
83319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83320       };
83321     } catch (Dali::DaliException e) {
83322       {
83323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83324       };
83325     } catch (...) {
83326       {
83327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83328       };
83329     }
83330   }
83331
83332   jresult = new Dali::Size((const Dali::Size &)result);
83333   return jresult;
83334 }
83335
83336
83337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83338   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83339   unsigned int arg2 ;
83340
83341   arg1 = (Dali::Toolkit::TableView *)jarg1;
83342   arg2 = (unsigned int)jarg2;
83343   {
83344     try {
83345       (arg1)->SetFitHeight(arg2);
83346     } catch (std::out_of_range& e) {
83347       {
83348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83349       };
83350     } catch (std::exception& e) {
83351       {
83352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83353       };
83354     } catch (Dali::DaliException e) {
83355       {
83356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83357       };
83358     } catch (...) {
83359       {
83360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83361       };
83362     }
83363   }
83364
83365 }
83366
83367
83368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83369   unsigned int jresult ;
83370   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83371   unsigned int arg2 ;
83372   bool result;
83373
83374   arg1 = (Dali::Toolkit::TableView *)jarg1;
83375   arg2 = (unsigned int)jarg2;
83376   {
83377     try {
83378       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (Dali::DaliException e) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83394       };
83395     }
83396   }
83397
83398   jresult = result;
83399   return jresult;
83400 }
83401
83402
83403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83404   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83405   unsigned int arg2 ;
83406
83407   arg1 = (Dali::Toolkit::TableView *)jarg1;
83408   arg2 = (unsigned int)jarg2;
83409   {
83410     try {
83411       (arg1)->SetFitWidth(arg2);
83412     } catch (std::out_of_range& e) {
83413       {
83414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83415       };
83416     } catch (std::exception& e) {
83417       {
83418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83419       };
83420     } catch (Dali::DaliException e) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83423       };
83424     } catch (...) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83427       };
83428     }
83429   }
83430
83431 }
83432
83433
83434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83435   unsigned int jresult ;
83436   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83437   unsigned int arg2 ;
83438   bool result;
83439
83440   arg1 = (Dali::Toolkit::TableView *)jarg1;
83441   arg2 = (unsigned int)jarg2;
83442   {
83443     try {
83444       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83445     } catch (std::out_of_range& e) {
83446       {
83447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (std::exception& e) {
83450       {
83451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (Dali::DaliException e) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83460       };
83461     }
83462   }
83463
83464   jresult = result;
83465   return jresult;
83466 }
83467
83468
83469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83471   unsigned int arg2 ;
83472   float arg3 ;
83473
83474   arg1 = (Dali::Toolkit::TableView *)jarg1;
83475   arg2 = (unsigned int)jarg2;
83476   arg3 = (float)jarg3;
83477   {
83478     try {
83479       (arg1)->SetFixedHeight(arg2,arg3);
83480     } catch (std::out_of_range& e) {
83481       {
83482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83483       };
83484     } catch (std::exception& e) {
83485       {
83486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83487       };
83488     } catch (Dali::DaliException e) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83491       };
83492     } catch (...) {
83493       {
83494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83495       };
83496     }
83497   }
83498
83499 }
83500
83501
83502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83503   float jresult ;
83504   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83505   unsigned int arg2 ;
83506   float result;
83507
83508   arg1 = (Dali::Toolkit::TableView *)jarg1;
83509   arg2 = (unsigned int)jarg2;
83510   {
83511     try {
83512       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83513     } catch (std::out_of_range& e) {
83514       {
83515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83516       };
83517     } catch (std::exception& e) {
83518       {
83519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83520       };
83521     } catch (Dali::DaliException e) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83524       };
83525     } catch (...) {
83526       {
83527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83528       };
83529     }
83530   }
83531
83532   jresult = result;
83533   return jresult;
83534 }
83535
83536
83537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83538   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83539   unsigned int arg2 ;
83540   float arg3 ;
83541
83542   arg1 = (Dali::Toolkit::TableView *)jarg1;
83543   arg2 = (unsigned int)jarg2;
83544   arg3 = (float)jarg3;
83545   {
83546     try {
83547       (arg1)->SetRelativeHeight(arg2,arg3);
83548     } catch (std::out_of_range& e) {
83549       {
83550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83551       };
83552     } catch (std::exception& e) {
83553       {
83554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83555       };
83556     } catch (Dali::DaliException e) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83563       };
83564     }
83565   }
83566
83567 }
83568
83569
83570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83571   float jresult ;
83572   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83573   unsigned int arg2 ;
83574   float result;
83575
83576   arg1 = (Dali::Toolkit::TableView *)jarg1;
83577   arg2 = (unsigned int)jarg2;
83578   {
83579     try {
83580       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83596       };
83597     }
83598   }
83599
83600   jresult = result;
83601   return jresult;
83602 }
83603
83604
83605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83607   unsigned int arg2 ;
83608   float arg3 ;
83609
83610   arg1 = (Dali::Toolkit::TableView *)jarg1;
83611   arg2 = (unsigned int)jarg2;
83612   arg3 = (float)jarg3;
83613   {
83614     try {
83615       (arg1)->SetFixedWidth(arg2,arg3);
83616     } catch (std::out_of_range& e) {
83617       {
83618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83619       };
83620     } catch (std::exception& e) {
83621       {
83622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83623       };
83624     } catch (Dali::DaliException e) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83627       };
83628     } catch (...) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83631       };
83632     }
83633   }
83634
83635 }
83636
83637
83638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83639   float jresult ;
83640   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83641   unsigned int arg2 ;
83642   float result;
83643
83644   arg1 = (Dali::Toolkit::TableView *)jarg1;
83645   arg2 = (unsigned int)jarg2;
83646   {
83647     try {
83648       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83649     } catch (std::out_of_range& e) {
83650       {
83651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83652       };
83653     } catch (std::exception& e) {
83654       {
83655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83656       };
83657     } catch (Dali::DaliException e) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83664       };
83665     }
83666   }
83667
83668   jresult = result;
83669   return jresult;
83670 }
83671
83672
83673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83674   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83675   unsigned int arg2 ;
83676   float arg3 ;
83677
83678   arg1 = (Dali::Toolkit::TableView *)jarg1;
83679   arg2 = (unsigned int)jarg2;
83680   arg3 = (float)jarg3;
83681   {
83682     try {
83683       (arg1)->SetRelativeWidth(arg2,arg3);
83684     } catch (std::out_of_range& e) {
83685       {
83686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83687       };
83688     } catch (std::exception& e) {
83689       {
83690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83691       };
83692     } catch (Dali::DaliException e) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83695       };
83696     } catch (...) {
83697       {
83698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83699       };
83700     }
83701   }
83702
83703 }
83704
83705
83706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83707   float jresult ;
83708   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83709   unsigned int arg2 ;
83710   float result;
83711
83712   arg1 = (Dali::Toolkit::TableView *)jarg1;
83713   arg2 = (unsigned int)jarg2;
83714   {
83715     try {
83716       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83717     } catch (std::out_of_range& e) {
83718       {
83719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (std::exception& e) {
83722       {
83723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83724       };
83725     } catch (Dali::DaliException e) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83728       };
83729     } catch (...) {
83730       {
83731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83732       };
83733     }
83734   }
83735
83736   jresult = result;
83737   return jresult;
83738 }
83739
83740
83741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83742   unsigned int jresult ;
83743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83744   unsigned int result;
83745
83746   arg1 = (Dali::Toolkit::TableView *)jarg1;
83747   {
83748     try {
83749       result = (unsigned int)(arg1)->GetRows();
83750     } catch (std::out_of_range& e) {
83751       {
83752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (std::exception& e) {
83755       {
83756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83757       };
83758     } catch (Dali::DaliException e) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83761       };
83762     } catch (...) {
83763       {
83764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83765       };
83766     }
83767   }
83768
83769   jresult = result;
83770   return jresult;
83771 }
83772
83773
83774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83775   unsigned int jresult ;
83776   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83777   unsigned int result;
83778
83779   arg1 = (Dali::Toolkit::TableView *)jarg1;
83780   {
83781     try {
83782       result = (unsigned int)(arg1)->GetColumns();
83783     } catch (std::out_of_range& e) {
83784       {
83785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (std::exception& e) {
83788       {
83789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83790       };
83791     } catch (Dali::DaliException e) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83794       };
83795     } catch (...) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83798       };
83799     }
83800   }
83801
83802   jresult = result;
83803   return jresult;
83804 }
83805
83806
83807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83808   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83809   Dali::Toolkit::TableView::CellPosition arg2 ;
83810   Dali::HorizontalAlignment::Type arg3 ;
83811   Dali::VerticalAlignment::Type arg4 ;
83812   Dali::Toolkit::TableView::CellPosition *argp2 ;
83813
83814   arg1 = (Dali::Toolkit::TableView *)jarg1;
83815   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83816   if (!argp2) {
83817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83818     return ;
83819   }
83820   arg2 = *argp2;
83821   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83822   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83823   {
83824     try {
83825       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83826     } catch (std::out_of_range& e) {
83827       {
83828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83829       };
83830     } catch (std::exception& e) {
83831       {
83832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83833       };
83834     } catch (Dali::DaliException e) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83837       };
83838     } catch (...) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83841       };
83842     }
83843   }
83844
83845 }
83846
83847
83848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83849   unsigned int jresult ;
83850   unsigned int result;
83851
83852   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83853   jresult = result;
83854   return jresult;
83855 }
83856
83857
83858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83859   int jresult ;
83860   int result;
83861
83862   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83863   jresult = (int)result;
83864   return jresult;
83865 }
83866
83867
83868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83869   int jresult ;
83870   int result;
83871
83872   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83873   jresult = (int)result;
83874   return jresult;
83875 }
83876
83877
83878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83879   int jresult ;
83880   int result;
83881
83882   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83883   jresult = (int)result;
83884   return jresult;
83885 }
83886
83887
83888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83889   int jresult ;
83890   int result;
83891
83892   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83893   jresult = (int)result;
83894   return jresult;
83895 }
83896
83897
83898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83899   int jresult ;
83900   int result;
83901
83902   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83903   jresult = (int)result;
83904   return jresult;
83905 }
83906
83907
83908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83909   int jresult ;
83910   int result;
83911
83912   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83913   jresult = (int)result;
83914   return jresult;
83915 }
83916
83917
83918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83919   int jresult ;
83920   int result;
83921
83922   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83923   jresult = (int)result;
83924   return jresult;
83925 }
83926
83927
83928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83929   int jresult ;
83930   int result;
83931
83932   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83933   jresult = (int)result;
83934   return jresult;
83935 }
83936
83937
83938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83939   int jresult ;
83940   int result;
83941
83942   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83943   jresult = (int)result;
83944   return jresult;
83945 }
83946
83947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83948   int jresult ;
83949   int result;
83950
83951   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83952   jresult = (int)result;
83953   return jresult;
83954 }
83955
83956
83957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83958   int jresult ;
83959   int result;
83960
83961   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83962   jresult = (int)result;
83963   return jresult;
83964 }
83965
83966
83967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83968   int jresult ;
83969   int result;
83970
83971   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83972   jresult = (int)result;
83973   return jresult;
83974 }
83975
83976
83977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83978   int jresult ;
83979   int result;
83980
83981   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83982   jresult = (int)result;
83983   return jresult;
83984 }
83985
83986
83987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83988   int jresult ;
83989   int result;
83990
83991   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83992   jresult = (int)result;
83993   return jresult;
83994 }
83995
83996
83997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83998   int jresult ;
83999   int result;
84000
84001   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84002   jresult = (int)result;
84003   return jresult;
84004 }
84005
84006
84007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84008   int jresult ;
84009   int result;
84010
84011   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84012   jresult = (int)result;
84013   return jresult;
84014 }
84015
84016
84017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84018   int jresult ;
84019   int result;
84020
84021   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84022   jresult = (int)result;
84023   return jresult;
84024 }
84025
84026
84027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84028   int jresult ;
84029   int result;
84030
84031   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84032   jresult = (int)result;
84033   return jresult;
84034 }
84035
84036
84037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84038   int jresult ;
84039   int result;
84040
84041   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84042   jresult = (int)result;
84043   return jresult;
84044 }
84045
84046
84047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84048   int jresult ;
84049   int result;
84050
84051   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84052   jresult = (int)result;
84053   return jresult;
84054 }
84055
84056
84057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84058   int jresult ;
84059   int result;
84060
84061   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84062   jresult = (int)result;
84063   return jresult;
84064 }
84065
84066
84067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84068   int jresult ;
84069   int result;
84070
84071   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84072   jresult = (int)result;
84073   return jresult;
84074 }
84075
84076
84077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84078   int jresult ;
84079   int result;
84080
84081   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84082   jresult = (int)result;
84083   return jresult;
84084 }
84085
84086
84087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84088   int jresult ;
84089   int result;
84090
84091   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84092   jresult = (int)result;
84093   return jresult;
84094 }
84095
84096
84097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84098   void * jresult ;
84099   Dali::Toolkit::TextLabel::Property *result = 0 ;
84100
84101   {
84102     try {
84103       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84104     } catch (std::out_of_range& e) {
84105       {
84106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84107       };
84108     } catch (std::exception& e) {
84109       {
84110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84111       };
84112     } catch (Dali::DaliException e) {
84113       {
84114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84115       };
84116     } catch (...) {
84117       {
84118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84119       };
84120     }
84121   }
84122
84123   jresult = (void *)result;
84124   return jresult;
84125 }
84126
84127
84128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84129   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84130
84131   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84132   {
84133     try {
84134       delete arg1;
84135     } catch (std::out_of_range& e) {
84136       {
84137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (std::exception& e) {
84140       {
84141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84142       };
84143     } catch (Dali::DaliException e) {
84144       {
84145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84146       };
84147     } catch (...) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84150       };
84151     }
84152   }
84153
84154 }
84155
84156
84157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84158   void * jresult ;
84159   Dali::Toolkit::TextLabel result;
84160
84161   {
84162     try {
84163       result = Dali::Toolkit::TextLabel::New();
84164
84165       // default behaviour of NUI TextLabel
84166       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84167     } catch (std::out_of_range& e) {
84168       {
84169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84170       };
84171     } catch (std::exception& e) {
84172       {
84173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84174       };
84175     } catch (Dali::DaliException e) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84178       };
84179     } catch (...) {
84180       {
84181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84182       };
84183     }
84184   }
84185
84186   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84187   return jresult;
84188 }
84189
84190
84191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84192   void * jresult ;
84193   std::string *arg1 = 0 ;
84194   Dali::Toolkit::TextLabel result;
84195
84196   if (!jarg1) {
84197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84198     return 0;
84199   }
84200   std::string arg1_str(jarg1);
84201   arg1 = &arg1_str;
84202   {
84203     try {
84204       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84205
84206       // default behaviour of NUI TextLabel
84207       result.SetProperty( Dali::Toolkit::DevelTextLabel::Property::VERTICAL_LINE_ALIGNMENT, Dali::Toolkit::DevelText::VerticalLineAlignment::MIDDLE );
84208     } catch (std::out_of_range& e) {
84209       {
84210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84211       };
84212     } catch (std::exception& e) {
84213       {
84214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84215       };
84216     } catch (Dali::DaliException e) {
84217       {
84218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84219       };
84220     } catch (...) {
84221       {
84222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84223       };
84224     }
84225   }
84226
84227   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84228
84229   //argout typemap for const std::string&
84230
84231   return jresult;
84232 }
84233
84234
84235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84236   void * jresult ;
84237   Dali::Toolkit::TextLabel *result = 0 ;
84238
84239   {
84240     try {
84241       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84242     } catch (std::out_of_range& e) {
84243       {
84244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84245       };
84246     } catch (std::exception& e) {
84247       {
84248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84249       };
84250     } catch (Dali::DaliException e) {
84251       {
84252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84253       };
84254     } catch (...) {
84255       {
84256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84257       };
84258     }
84259   }
84260
84261   jresult = (void *)result;
84262   return jresult;
84263 }
84264
84265
84266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84267   void * jresult ;
84268   Dali::Toolkit::TextLabel *arg1 = 0 ;
84269   Dali::Toolkit::TextLabel *result = 0 ;
84270
84271   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84272   if (!arg1) {
84273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84274     return 0;
84275   }
84276   {
84277     try {
84278       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84279     } catch (std::out_of_range& e) {
84280       {
84281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (std::exception& e) {
84284       {
84285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (Dali::DaliException e) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84290       };
84291     } catch (...) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84294       };
84295     }
84296   }
84297
84298   jresult = (void *)result;
84299   return jresult;
84300 }
84301
84302
84303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84304   void * jresult ;
84305   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84306   Dali::Toolkit::TextLabel *arg2 = 0 ;
84307   Dali::Toolkit::TextLabel *result = 0 ;
84308
84309   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84310   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84311   if (!arg2) {
84312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84313     return 0;
84314   }
84315   {
84316     try {
84317       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84318     } catch (std::out_of_range& e) {
84319       {
84320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (std::exception& e) {
84323       {
84324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (Dali::DaliException e) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84329       };
84330     } catch (...) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84333       };
84334     }
84335   }
84336
84337   jresult = (void *)result;
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84343   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84344
84345   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84346   {
84347     try {
84348       delete arg1;
84349     } catch (std::out_of_range& e) {
84350       {
84351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84352       };
84353     } catch (std::exception& e) {
84354       {
84355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84356       };
84357     } catch (Dali::DaliException e) {
84358       {
84359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84360       };
84361     } catch (...) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84364       };
84365     }
84366   }
84367
84368 }
84369
84370
84371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84372   void * jresult ;
84373   Dali::BaseHandle arg1 ;
84374   Dali::BaseHandle *argp1 ;
84375   Dali::Toolkit::TextLabel result;
84376
84377   argp1 = (Dali::BaseHandle *)jarg1;
84378   if (!argp1) {
84379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84380     return 0;
84381   }
84382   arg1 = *argp1;
84383   {
84384     try {
84385       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84386     } catch (std::out_of_range& e) {
84387       {
84388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84389       };
84390     } catch (std::exception& e) {
84391       {
84392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84393       };
84394     } catch (Dali::DaliException e) {
84395       {
84396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84397       };
84398     } catch (...) {
84399       {
84400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84401       };
84402     }
84403   }
84404
84405   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84411   void * jresult ;
84412   Dali::Toolkit::AccessibilityManager *result = 0 ;
84413
84414   {
84415     try {
84416       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84417     } catch (std::out_of_range& e) {
84418       {
84419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84420       };
84421     } catch (std::exception& e) {
84422       {
84423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84424       };
84425     } catch (Dali::DaliException e) {
84426       {
84427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84428       };
84429     } catch (...) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84432       };
84433     }
84434   }
84435
84436   jresult = (void *)result;
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84443
84444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84445   {
84446     try {
84447       delete arg1;
84448     } catch (std::out_of_range& e) {
84449       {
84450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84451       };
84452     } catch (std::exception& e) {
84453       {
84454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84455       };
84456     } catch (Dali::DaliException e) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84459       };
84460     } catch (...) {
84461       {
84462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84463       };
84464     }
84465   }
84466
84467 }
84468
84469
84470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84471   void * jresult ;
84472   Dali::Toolkit::AccessibilityManager result;
84473
84474   {
84475     try {
84476       result = Dali::Toolkit::AccessibilityManager::Get();
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (Dali::DaliException e) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84492       };
84493     }
84494   }
84495
84496   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84503   Dali::Actor arg2 ;
84504   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84505   std::string *arg4 = 0 ;
84506   Dali::Actor *argp2 ;
84507
84508   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84509   argp2 = (Dali::Actor *)jarg2;
84510   if (!argp2) {
84511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84512     return ;
84513   }
84514   arg2 = *argp2;
84515   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84516   if (!jarg4) {
84517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84518     return ;
84519   }
84520   std::string arg4_str(jarg4);
84521   arg4 = &arg4_str;
84522   {
84523     try {
84524       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84525     } catch (std::out_of_range& e) {
84526       {
84527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84528       };
84529     } catch (std::exception& e) {
84530       {
84531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84532       };
84533     } catch (Dali::DaliException e) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84536       };
84537     } catch (...) {
84538       {
84539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84540       };
84541     }
84542   }
84543
84544
84545   //argout typemap for const std::string&
84546
84547 }
84548
84549
84550 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84551   char * jresult ;
84552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84553   Dali::Actor arg2 ;
84554   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84555   Dali::Actor *argp2 ;
84556   std::string result;
84557
84558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84559   argp2 = (Dali::Actor *)jarg2;
84560   if (!argp2) {
84561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84562     return 0;
84563   }
84564   arg2 = *argp2;
84565   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84566   {
84567     try {
84568       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (Dali::DaliException e) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84584       };
84585     }
84586   }
84587
84588   jresult = SWIG_csharp_string_callback((&result)->c_str());
84589   return jresult;
84590 }
84591
84592
84593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84595   Dali::Actor arg2 ;
84596   unsigned int arg3 ;
84597   Dali::Actor *argp2 ;
84598
84599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84600   argp2 = (Dali::Actor *)jarg2;
84601   if (!argp2) {
84602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84603     return ;
84604   }
84605   arg2 = *argp2;
84606   arg3 = (unsigned int)jarg3;
84607   {
84608     try {
84609       (arg1)->SetFocusOrder(arg2,arg3);
84610     } catch (std::out_of_range& e) {
84611       {
84612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (std::exception& e) {
84615       {
84616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84617       };
84618     } catch (Dali::DaliException e) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84621       };
84622     } catch (...) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84625       };
84626     }
84627   }
84628
84629 }
84630
84631
84632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84633   unsigned int jresult ;
84634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84635   Dali::Actor arg2 ;
84636   Dali::Actor *argp2 ;
84637   unsigned int result;
84638
84639   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84640   argp2 = (Dali::Actor *)jarg2;
84641   if (!argp2) {
84642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84643     return 0;
84644   }
84645   arg2 = *argp2;
84646   {
84647     try {
84648       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84649     } catch (std::out_of_range& e) {
84650       {
84651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (std::exception& e) {
84654       {
84655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84656       };
84657     } catch (Dali::DaliException e) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84660       };
84661     } catch (...) {
84662       {
84663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84664       };
84665     }
84666   }
84667
84668   jresult = result;
84669   return jresult;
84670 }
84671
84672
84673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84674   unsigned int jresult ;
84675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84676   unsigned int result;
84677
84678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84679   {
84680     try {
84681       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84682     } catch (std::out_of_range& e) {
84683       {
84684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84685       };
84686     } catch (std::exception& e) {
84687       {
84688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84689       };
84690     } catch (Dali::DaliException e) {
84691       {
84692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84693       };
84694     } catch (...) {
84695       {
84696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84697       };
84698     }
84699   }
84700
84701   jresult = result;
84702   return jresult;
84703 }
84704
84705
84706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84707   void * jresult ;
84708   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84709   unsigned int arg2 ;
84710   Dali::Actor result;
84711
84712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84713   arg2 = (unsigned int)jarg2;
84714   {
84715     try {
84716       result = (arg1)->GetActorByFocusOrder(arg2);
84717     } catch (std::out_of_range& e) {
84718       {
84719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (std::exception& e) {
84722       {
84723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (Dali::DaliException e) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84728       };
84729     } catch (...) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84732       };
84733     }
84734   }
84735
84736   jresult = new Dali::Actor((const Dali::Actor &)result);
84737   return jresult;
84738 }
84739
84740
84741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84742   unsigned int jresult ;
84743   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84744   Dali::Actor arg2 ;
84745   Dali::Actor *argp2 ;
84746   bool result;
84747
84748   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84749   argp2 = (Dali::Actor *)jarg2;
84750   if (!argp2) {
84751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84752     return 0;
84753   }
84754   arg2 = *argp2;
84755   {
84756     try {
84757       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84758     } catch (std::out_of_range& e) {
84759       {
84760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84761       };
84762     } catch (std::exception& e) {
84763       {
84764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84765       };
84766     } catch (Dali::DaliException e) {
84767       {
84768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84769       };
84770     } catch (...) {
84771       {
84772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84773       };
84774     }
84775   }
84776
84777   jresult = result;
84778   return jresult;
84779 }
84780
84781
84782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84783   void * jresult ;
84784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84785   Dali::Actor result;
84786
84787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84788   {
84789     try {
84790       result = (arg1)->GetCurrentFocusActor();
84791     } catch (std::out_of_range& e) {
84792       {
84793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (std::exception& e) {
84796       {
84797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84798       };
84799     } catch (Dali::DaliException e) {
84800       {
84801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84802       };
84803     } catch (...) {
84804       {
84805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84806       };
84807     }
84808   }
84809
84810   jresult = new Dali::Actor((const Dali::Actor &)result);
84811   return jresult;
84812 }
84813
84814
84815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84816   void * jresult ;
84817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84818   Dali::Actor result;
84819
84820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84821   {
84822     try {
84823       result = (arg1)->GetCurrentFocusGroup();
84824     } catch (std::out_of_range& e) {
84825       {
84826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84827       };
84828     } catch (std::exception& e) {
84829       {
84830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84831       };
84832     } catch (Dali::DaliException e) {
84833       {
84834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84835       };
84836     } catch (...) {
84837       {
84838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84839       };
84840     }
84841   }
84842
84843   jresult = new Dali::Actor((const Dali::Actor &)result);
84844   return jresult;
84845 }
84846
84847
84848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84849   unsigned int jresult ;
84850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84851   unsigned int result;
84852
84853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84854   {
84855     try {
84856       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84857     } catch (std::out_of_range& e) {
84858       {
84859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (std::exception& e) {
84862       {
84863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (Dali::DaliException e) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84868       };
84869     } catch (...) {
84870       {
84871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84872       };
84873     }
84874   }
84875
84876   jresult = result;
84877   return jresult;
84878 }
84879
84880
84881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84882   unsigned int jresult ;
84883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84884   bool result;
84885
84886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84887   {
84888     try {
84889       result = (bool)(arg1)->MoveFocusForward();
84890     } catch (std::out_of_range& e) {
84891       {
84892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84893       };
84894     } catch (std::exception& e) {
84895       {
84896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84897       };
84898     } catch (Dali::DaliException e) {
84899       {
84900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84901       };
84902     } catch (...) {
84903       {
84904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84905       };
84906     }
84907   }
84908
84909   jresult = result;
84910   return jresult;
84911 }
84912
84913
84914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84915   unsigned int jresult ;
84916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84917   bool result;
84918
84919   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84920   {
84921     try {
84922       result = (bool)(arg1)->MoveFocusBackward();
84923     } catch (std::out_of_range& e) {
84924       {
84925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84926       };
84927     } catch (std::exception& e) {
84928       {
84929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84930       };
84931     } catch (Dali::DaliException e) {
84932       {
84933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84934       };
84935     } catch (...) {
84936       {
84937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84938       };
84939     }
84940   }
84941
84942   jresult = result;
84943   return jresult;
84944 }
84945
84946
84947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84949
84950   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84951   {
84952     try {
84953       (arg1)->ClearFocus();
84954     } catch (std::out_of_range& e) {
84955       {
84956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84957       };
84958     } catch (std::exception& e) {
84959       {
84960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84961       };
84962     } catch (Dali::DaliException e) {
84963       {
84964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84965       };
84966     } catch (...) {
84967       {
84968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84969       };
84970     }
84971   }
84972
84973 }
84974
84975
84976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84977   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84978
84979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84980   {
84981     try {
84982       (arg1)->Reset();
84983     } catch (std::out_of_range& e) {
84984       {
84985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84986       };
84987     } catch (std::exception& e) {
84988       {
84989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84990       };
84991     } catch (Dali::DaliException e) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84998       };
84999     }
85000   }
85001
85002 }
85003
85004
85005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85007   Dali::Actor arg2 ;
85008   bool arg3 ;
85009   Dali::Actor *argp2 ;
85010
85011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85012   argp2 = (Dali::Actor *)jarg2;
85013   if (!argp2) {
85014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85015     return ;
85016   }
85017   arg2 = *argp2;
85018   arg3 = jarg3 ? true : false;
85019   {
85020     try {
85021       (arg1)->SetFocusGroup(arg2,arg3);
85022     } catch (std::out_of_range& e) {
85023       {
85024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85025       };
85026     } catch (std::exception& e) {
85027       {
85028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85029       };
85030     } catch (Dali::DaliException e) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85037       };
85038     }
85039   }
85040
85041 }
85042
85043
85044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85045   unsigned int jresult ;
85046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85047   Dali::Actor arg2 ;
85048   Dali::Actor *argp2 ;
85049   bool result;
85050
85051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85052   argp2 = (Dali::Actor *)jarg2;
85053   if (!argp2) {
85054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85055     return 0;
85056   }
85057   arg2 = *argp2;
85058   {
85059     try {
85060       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85061     } catch (std::out_of_range& e) {
85062       {
85063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (std::exception& e) {
85066       {
85067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85068       };
85069     } catch (Dali::DaliException e) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85072       };
85073     } catch (...) {
85074       {
85075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85076       };
85077     }
85078   }
85079
85080   jresult = result;
85081   return jresult;
85082 }
85083
85084
85085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85087   bool arg2 ;
85088
85089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85090   arg2 = jarg2 ? true : false;
85091   {
85092     try {
85093       (arg1)->SetGroupMode(arg2);
85094     } catch (std::out_of_range& e) {
85095       {
85096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85097       };
85098     } catch (std::exception& e) {
85099       {
85100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85101       };
85102     } catch (Dali::DaliException e) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85105       };
85106     } catch (...) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85109       };
85110     }
85111   }
85112
85113 }
85114
85115
85116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85117   unsigned int jresult ;
85118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85119   bool result;
85120
85121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85122   {
85123     try {
85124       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85125     } catch (std::out_of_range& e) {
85126       {
85127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85128       };
85129     } catch (std::exception& e) {
85130       {
85131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85132       };
85133     } catch (Dali::DaliException e) {
85134       {
85135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85136       };
85137     } catch (...) {
85138       {
85139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85140       };
85141     }
85142   }
85143
85144   jresult = result;
85145   return jresult;
85146 }
85147
85148
85149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85151   bool arg2 ;
85152
85153   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85154   arg2 = jarg2 ? true : false;
85155   {
85156     try {
85157       (arg1)->SetWrapMode(arg2);
85158     } catch (std::out_of_range& e) {
85159       {
85160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85161       };
85162     } catch (std::exception& e) {
85163       {
85164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85165       };
85166     } catch (Dali::DaliException e) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85169       };
85170     } catch (...) {
85171       {
85172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85173       };
85174     }
85175   }
85176
85177 }
85178
85179
85180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85181   unsigned int jresult ;
85182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85183   bool result;
85184
85185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85186   {
85187     try {
85188       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85189     } catch (std::out_of_range& e) {
85190       {
85191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85192       };
85193     } catch (std::exception& e) {
85194       {
85195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85196       };
85197     } catch (Dali::DaliException e) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85200       };
85201     } catch (...) {
85202       {
85203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85204       };
85205     }
85206   }
85207
85208   jresult = result;
85209   return jresult;
85210 }
85211
85212
85213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85215   Dali::Actor arg2 ;
85216   Dali::Actor *argp2 ;
85217
85218   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85219   argp2 = (Dali::Actor *)jarg2;
85220   if (!argp2) {
85221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85222     return ;
85223   }
85224   arg2 = *argp2;
85225   {
85226     try {
85227       (arg1)->SetFocusIndicatorActor(arg2);
85228     } catch (std::out_of_range& e) {
85229       {
85230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85231       };
85232     } catch (std::exception& e) {
85233       {
85234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85235       };
85236     } catch (Dali::DaliException e) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85239       };
85240     } catch (...) {
85241       {
85242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85243       };
85244     }
85245   }
85246
85247 }
85248
85249
85250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85251   void * jresult ;
85252   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85253   Dali::Actor result;
85254
85255   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85256   {
85257     try {
85258       result = (arg1)->GetFocusIndicatorActor();
85259     } catch (std::out_of_range& e) {
85260       {
85261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (std::exception& e) {
85264       {
85265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85266       };
85267     } catch (Dali::DaliException e) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85270       };
85271     } catch (...) {
85272       {
85273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85274       };
85275     }
85276   }
85277
85278   jresult = new Dali::Actor((const Dali::Actor &)result);
85279   return jresult;
85280 }
85281
85282
85283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85284   void * jresult ;
85285   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85286   Dali::Actor arg2 ;
85287   Dali::Actor *argp2 ;
85288   Dali::Actor result;
85289
85290   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85291   argp2 = (Dali::Actor *)jarg2;
85292   if (!argp2) {
85293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85294     return 0;
85295   }
85296   arg2 = *argp2;
85297   {
85298     try {
85299       result = (arg1)->GetFocusGroup(arg2);
85300     } catch (std::out_of_range& e) {
85301       {
85302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85303       };
85304     } catch (std::exception& e) {
85305       {
85306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85307       };
85308     } catch (Dali::DaliException e) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85311       };
85312     } catch (...) {
85313       {
85314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85315       };
85316     }
85317   }
85318
85319   jresult = new Dali::Actor((const Dali::Actor &)result);
85320   return jresult;
85321 }
85322
85323
85324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85325   void * jresult ;
85326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85327   Dali::Vector2 result;
85328
85329   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85330   {
85331     try {
85332       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85333     } catch (std::out_of_range& e) {
85334       {
85335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85336       };
85337     } catch (std::exception& e) {
85338       {
85339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85340       };
85341     } catch (Dali::DaliException e) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85344       };
85345     } catch (...) {
85346       {
85347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85348       };
85349     }
85350   }
85351
85352   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85353   return jresult;
85354 }
85355
85356
85357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85358   void * jresult ;
85359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85360   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85361
85362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85363   {
85364     try {
85365       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85366     } catch (std::out_of_range& e) {
85367       {
85368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85369       };
85370     } catch (std::exception& e) {
85371       {
85372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85373       };
85374     } catch (Dali::DaliException e) {
85375       {
85376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85377       };
85378     } catch (...) {
85379       {
85380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85381       };
85382     }
85383   }
85384
85385   jresult = (void *)result;
85386   return jresult;
85387 }
85388
85389
85390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85391   void * jresult ;
85392   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85393   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85394
85395   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85396   {
85397     try {
85398       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85399     } catch (std::out_of_range& e) {
85400       {
85401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (std::exception& e) {
85404       {
85405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85406       };
85407     } catch (Dali::DaliException e) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85410       };
85411     } catch (...) {
85412       {
85413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85414       };
85415     }
85416   }
85417
85418   jresult = (void *)result;
85419   return jresult;
85420 }
85421
85422
85423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85424   void * jresult ;
85425   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85426   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85427
85428   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85429   {
85430     try {
85431       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85432     } catch (std::out_of_range& e) {
85433       {
85434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (std::exception& e) {
85437       {
85438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85439       };
85440     } catch (Dali::DaliException e) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85443       };
85444     } catch (...) {
85445       {
85446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85447       };
85448     }
85449   }
85450
85451   jresult = (void *)result;
85452   return jresult;
85453 }
85454
85455
85456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85457   void * jresult ;
85458   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85459   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85460
85461   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85462   {
85463     try {
85464       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85465     } catch (std::out_of_range& e) {
85466       {
85467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85468       };
85469     } catch (std::exception& e) {
85470       {
85471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85472       };
85473     } catch (Dali::DaliException e) {
85474       {
85475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85476       };
85477     } catch (...) {
85478       {
85479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85480       };
85481     }
85482   }
85483
85484   jresult = (void *)result;
85485   return jresult;
85486 }
85487
85488
85489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85490   void * jresult ;
85491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85492   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85493
85494   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85495   {
85496     try {
85497       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85498     } catch (std::out_of_range& e) {
85499       {
85500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85501       };
85502     } catch (std::exception& e) {
85503       {
85504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85505       };
85506     } catch (Dali::DaliException e) {
85507       {
85508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85509       };
85510     } catch (...) {
85511       {
85512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85513       };
85514     }
85515   }
85516
85517   jresult = (void *)result;
85518   return jresult;
85519 }
85520
85521
85522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85523   void * jresult ;
85524   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85525   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85526
85527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85528   {
85529     try {
85530       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85531     } catch (std::out_of_range& e) {
85532       {
85533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85534       };
85535     } catch (std::exception& e) {
85536       {
85537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85538       };
85539     } catch (Dali::DaliException e) {
85540       {
85541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85542       };
85543     } catch (...) {
85544       {
85545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85546       };
85547     }
85548   }
85549
85550   jresult = (void *)result;
85551   return jresult;
85552 }
85553
85554
85555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85556   void * jresult ;
85557   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85558   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85559
85560   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85561   {
85562     try {
85563       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85564     } catch (std::out_of_range& e) {
85565       {
85566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (std::exception& e) {
85569       {
85570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85571       };
85572     } catch (Dali::DaliException e) {
85573       {
85574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85575       };
85576     } catch (...) {
85577       {
85578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85579       };
85580     }
85581   }
85582
85583   jresult = (void *)result;
85584   return jresult;
85585 }
85586
85587
85588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85589   void * jresult ;
85590   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85591   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85592
85593   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85594   {
85595     try {
85596       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85597     } catch (std::out_of_range& e) {
85598       {
85599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85600       };
85601     } catch (std::exception& e) {
85602       {
85603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85604       };
85605     } catch (Dali::DaliException e) {
85606       {
85607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85608       };
85609     } catch (...) {
85610       {
85611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85612       };
85613     }
85614   }
85615
85616   jresult = (void *)result;
85617   return jresult;
85618 }
85619
85620
85621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85622   void * jresult ;
85623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85624   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85625
85626   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85627   {
85628     try {
85629       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85630     } catch (std::out_of_range& e) {
85631       {
85632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85633       };
85634     } catch (std::exception& e) {
85635       {
85636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85637       };
85638     } catch (Dali::DaliException e) {
85639       {
85640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85641       };
85642     } catch (...) {
85643       {
85644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85645       };
85646     }
85647   }
85648
85649   jresult = (void *)result;
85650   return jresult;
85651 }
85652
85653
85654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85655   void * jresult ;
85656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85657   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85658
85659   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85660   {
85661     try {
85662       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85663     } catch (std::out_of_range& e) {
85664       {
85665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85666       };
85667     } catch (std::exception& e) {
85668       {
85669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85670       };
85671     } catch (Dali::DaliException e) {
85672       {
85673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85674       };
85675     } catch (...) {
85676       {
85677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85678       };
85679     }
85680   }
85681
85682   jresult = (void *)result;
85683   return jresult;
85684 }
85685
85686
85687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85688   void * jresult ;
85689   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85690   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85691
85692   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85693   {
85694     try {
85695       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85696     } catch (std::out_of_range& e) {
85697       {
85698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (std::exception& e) {
85701       {
85702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85703       };
85704     } catch (Dali::DaliException e) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85707       };
85708     } catch (...) {
85709       {
85710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85711       };
85712     }
85713   }
85714
85715   jresult = (void *)result;
85716   return jresult;
85717 }
85718
85719
85720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85721   void * jresult ;
85722   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85723   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85724
85725   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85726   {
85727     try {
85728       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85729     } catch (std::out_of_range& e) {
85730       {
85731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85732       };
85733     } catch (std::exception& e) {
85734       {
85735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85736       };
85737     } catch (Dali::DaliException e) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85740       };
85741     } catch (...) {
85742       {
85743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85744       };
85745     }
85746   }
85747
85748   jresult = (void *)result;
85749   return jresult;
85750 }
85751
85752
85753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85754   void * jresult ;
85755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85756   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85757
85758   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85759   {
85760     try {
85761       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85762     } catch (std::out_of_range& e) {
85763       {
85764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (std::exception& e) {
85767       {
85768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85769       };
85770     } catch (Dali::DaliException e) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85773       };
85774     } catch (...) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85777       };
85778     }
85779   }
85780
85781   jresult = (void *)result;
85782   return jresult;
85783 }
85784
85785
85786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85787   void * jresult ;
85788   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85789   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85790
85791   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85792   {
85793     try {
85794       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85795     } catch (std::out_of_range& e) {
85796       {
85797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (std::exception& e) {
85800       {
85801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85802       };
85803     } catch (Dali::DaliException e) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85806       };
85807     } catch (...) {
85808       {
85809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85810       };
85811     }
85812   }
85813
85814   jresult = (void *)result;
85815   return jresult;
85816 }
85817
85818
85819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85820   void * jresult ;
85821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85822   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85823
85824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85825   {
85826     try {
85827       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85835       };
85836     } catch (Dali::DaliException e) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85839       };
85840     } catch (...) {
85841       {
85842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85843       };
85844     }
85845   }
85846
85847   jresult = (void *)result;
85848   return jresult;
85849 }
85850
85851
85852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85853   void * jresult ;
85854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85856
85857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85858   {
85859     try {
85860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85861     } catch (std::out_of_range& e) {
85862       {
85863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (std::exception& e) {
85866       {
85867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (Dali::DaliException e) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85872       };
85873     } catch (...) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85876       };
85877     }
85878   }
85879
85880   jresult = (void *)result;
85881   return jresult;
85882 }
85883
85884
85885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85886   void * jresult ;
85887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85888   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85889
85890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85891   {
85892     try {
85893       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85894     } catch (std::out_of_range& e) {
85895       {
85896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (std::exception& e) {
85899       {
85900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85901       };
85902     } catch (Dali::DaliException e) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85905       };
85906     } catch (...) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85909       };
85910     }
85911   }
85912
85913   jresult = (void *)result;
85914   return jresult;
85915 }
85916
85917
85918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85919   void * jresult ;
85920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85921   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85922
85923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85924   {
85925     try {
85926       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85927     } catch (std::out_of_range& e) {
85928       {
85929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (std::exception& e) {
85932       {
85933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85934       };
85935     } catch (Dali::DaliException e) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85938       };
85939     } catch (...) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85942       };
85943     }
85944   }
85945
85946   jresult = (void *)result;
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85952   void * jresult ;
85953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85954   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85955
85956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85957   {
85958     try {
85959       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85960     } catch (std::out_of_range& e) {
85961       {
85962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (std::exception& e) {
85965       {
85966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85967       };
85968     } catch (Dali::DaliException e) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85975       };
85976     }
85977   }
85978
85979   jresult = (void *)result;
85980   return jresult;
85981 }
85982
85983
85984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85985   void * jresult ;
85986   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85987   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85988
85989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85990   {
85991     try {
85992       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85993     } catch (std::out_of_range& e) {
85994       {
85995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (std::exception& e) {
85998       {
85999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86000       };
86001     } catch (Dali::DaliException e) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86004       };
86005     } catch (...) {
86006       {
86007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86008       };
86009     }
86010   }
86011
86012   jresult = (void *)result;
86013   return jresult;
86014 }
86015
86016
86017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86018   void * jresult ;
86019   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86020   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86021
86022   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86023   {
86024     try {
86025       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86026     } catch (std::out_of_range& e) {
86027       {
86028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (std::exception& e) {
86031       {
86032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (Dali::DaliException e) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86037       };
86038     } catch (...) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86041       };
86042     }
86043   }
86044
86045   jresult = (void *)result;
86046   return jresult;
86047 }
86048
86049
86050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86051   void * jresult ;
86052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86053   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86054
86055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86056   {
86057     try {
86058       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86059     } catch (std::out_of_range& e) {
86060       {
86061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (std::exception& e) {
86064       {
86065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86066       };
86067     } catch (Dali::DaliException e) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86070       };
86071     } catch (...) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86074       };
86075     }
86076   }
86077
86078   jresult = (void *)result;
86079   return jresult;
86080 }
86081
86082
86083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86084   void * jresult ;
86085   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86086   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86087
86088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86089   {
86090     try {
86091       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86092     } catch (std::out_of_range& e) {
86093       {
86094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (std::exception& e) {
86097       {
86098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86099       };
86100     } catch (Dali::DaliException e) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86103       };
86104     } catch (...) {
86105       {
86106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86107       };
86108     }
86109   }
86110
86111   jresult = (void *)result;
86112   return jresult;
86113 }
86114
86115
86116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86117   void * jresult ;
86118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86119   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86120
86121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86122   {
86123     try {
86124       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86125     } catch (std::out_of_range& e) {
86126       {
86127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (std::exception& e) {
86130       {
86131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86132       };
86133     } catch (Dali::DaliException e) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86136       };
86137     } catch (...) {
86138       {
86139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86140       };
86141     }
86142   }
86143
86144   jresult = (void *)result;
86145   return jresult;
86146 }
86147
86148
86149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86150   void * jresult ;
86151   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86152   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86153
86154   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86155   {
86156     try {
86157       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86158     } catch (std::out_of_range& e) {
86159       {
86160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (std::exception& e) {
86163       {
86164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (Dali::DaliException e) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86169       };
86170     } catch (...) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86173       };
86174     }
86175   }
86176
86177   jresult = (void *)result;
86178   return jresult;
86179 }
86180
86181
86182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86183   void * jresult ;
86184   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86185   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86186
86187   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86188   {
86189     try {
86190       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86191     } catch (std::out_of_range& e) {
86192       {
86193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (std::exception& e) {
86196       {
86197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86198       };
86199     } catch (Dali::DaliException e) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86202       };
86203     } catch (...) {
86204       {
86205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86206       };
86207     }
86208   }
86209
86210   jresult = (void *)result;
86211   return jresult;
86212 }
86213
86214
86215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86216   void * jresult ;
86217   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86218   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86219
86220   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86221   {
86222     try {
86223       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86224     } catch (std::out_of_range& e) {
86225       {
86226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (std::exception& e) {
86229       {
86230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86231       };
86232     } catch (Dali::DaliException e) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86235       };
86236     } catch (...) {
86237       {
86238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86239       };
86240     }
86241   }
86242
86243   jresult = (void *)result;
86244   return jresult;
86245 }
86246
86247
86248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86249   void * jresult ;
86250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86251   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86252
86253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86254   {
86255     try {
86256       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86257     } catch (std::out_of_range& e) {
86258       {
86259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86260       };
86261     } catch (std::exception& e) {
86262       {
86263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86264       };
86265     } catch (Dali::DaliException e) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86268       };
86269     } catch (...) {
86270       {
86271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86272       };
86273     }
86274   }
86275
86276   jresult = (void *)result;
86277   return jresult;
86278 }
86279
86280
86281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86282   void * jresult ;
86283   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86284   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86285
86286   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86287   {
86288     try {
86289       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86290     } catch (std::out_of_range& e) {
86291       {
86292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (std::exception& e) {
86295       {
86296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86297       };
86298     } catch (Dali::DaliException e) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86301       };
86302     } catch (...) {
86303       {
86304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86305       };
86306     }
86307   }
86308
86309   jresult = (void *)result;
86310   return jresult;
86311 }
86312
86313
86314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86315   void * jresult ;
86316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86317   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86318
86319   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86320   {
86321     try {
86322       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86323     } catch (std::out_of_range& e) {
86324       {
86325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (std::exception& e) {
86328       {
86329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86330       };
86331     } catch (Dali::DaliException e) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86334       };
86335     } catch (...) {
86336       {
86337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86338       };
86339     }
86340   }
86341
86342   jresult = (void *)result;
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86348   void * jresult ;
86349   Dali::Toolkit::StyleManager *result = 0 ;
86350
86351   {
86352     try {
86353       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86354     } catch (std::out_of_range& e) {
86355       {
86356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (std::exception& e) {
86359       {
86360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (Dali::DaliException e) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372
86373   jresult = (void *)result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86379   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86380
86381   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86382   {
86383     try {
86384       delete arg1;
86385     } catch (std::out_of_range& e) {
86386       {
86387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (std::exception& e) {
86390       {
86391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86392       };
86393     } catch (Dali::DaliException e) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86400       };
86401     }
86402   }
86403
86404 }
86405
86406
86407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86408   void * jresult ;
86409   Dali::Toolkit::StyleManager result;
86410
86411   {
86412     try {
86413       result = Dali::Toolkit::StyleManager::Get();
86414     } catch (std::out_of_range& e) {
86415       {
86416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (std::exception& e) {
86419       {
86420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (Dali::DaliException e) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86425       };
86426     } catch (...) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86429       };
86430     }
86431   }
86432
86433   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86434   return jresult;
86435 }
86436
86437
86438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86439   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86440   std::string *arg2 = 0 ;
86441
86442   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86443   if (!jarg2) {
86444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86445     return ;
86446   }
86447   std::string arg2_str(jarg2);
86448   arg2 = &arg2_str;
86449   {
86450     try {
86451       (arg1)->ApplyTheme((std::string const &)*arg2);
86452     } catch (std::out_of_range& e) {
86453       {
86454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (std::exception& e) {
86457       {
86458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86459       };
86460     } catch (Dali::DaliException e) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86463       };
86464     } catch (...) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86467       };
86468     }
86469   }
86470
86471
86472   //argout typemap for const std::string&
86473
86474 }
86475
86476
86477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86478   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86479
86480   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86481   {
86482     try {
86483       (arg1)->ApplyDefaultTheme();
86484     } catch (std::out_of_range& e) {
86485       {
86486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86487       };
86488     } catch (std::exception& e) {
86489       {
86490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86491       };
86492     } catch (Dali::DaliException e) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86495       };
86496     } catch (...) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86499       };
86500     }
86501   }
86502
86503 }
86504
86505
86506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86507   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86508   std::string *arg2 = 0 ;
86509   Dali::Property::Value *arg3 = 0 ;
86510
86511   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86512   if (!jarg2) {
86513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86514     return ;
86515   }
86516   std::string arg2_str(jarg2);
86517   arg2 = &arg2_str;
86518   arg3 = (Dali::Property::Value *)jarg3;
86519   if (!arg3) {
86520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86521     return ;
86522   }
86523   {
86524     try {
86525       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86526     } catch (std::out_of_range& e) {
86527       {
86528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86529       };
86530     } catch (std::exception& e) {
86531       {
86532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86533       };
86534     } catch (Dali::DaliException e) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86537       };
86538     } catch (...) {
86539       {
86540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86541       };
86542     }
86543   }
86544
86545
86546   //argout typemap for const std::string&
86547
86548 }
86549
86550
86551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86552   unsigned int jresult ;
86553   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86554   std::string *arg2 = 0 ;
86555   Dali::Property::Value *arg3 = 0 ;
86556   bool result;
86557
86558   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86559   if (!jarg2) {
86560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86561     return 0;
86562   }
86563   std::string arg2_str(jarg2);
86564   arg2 = &arg2_str;
86565   arg3 = (Dali::Property::Value *)jarg3;
86566   if (!arg3) {
86567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86568     return 0;
86569   }
86570   {
86571     try {
86572       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86573     } catch (std::out_of_range& e) {
86574       {
86575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (std::exception& e) {
86578       {
86579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86580       };
86581     } catch (Dali::DaliException e) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86584       };
86585     } catch (...) {
86586       {
86587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86588       };
86589     }
86590   }
86591
86592   jresult = result;
86593
86594   //argout typemap for const std::string&
86595
86596   return jresult;
86597 }
86598
86599
86600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86601   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86602   Dali::Toolkit::Control arg2 ;
86603   std::string *arg3 = 0 ;
86604   std::string *arg4 = 0 ;
86605   Dali::Toolkit::Control *argp2 ;
86606
86607   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86608   argp2 = (Dali::Toolkit::Control *)jarg2;
86609   if (!argp2) {
86610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86611     return ;
86612   }
86613   arg2 = *argp2;
86614   if (!jarg3) {
86615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86616     return ;
86617   }
86618   std::string arg3_str(jarg3);
86619   arg3 = &arg3_str;
86620   if (!jarg4) {
86621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86622     return ;
86623   }
86624   std::string arg4_str(jarg4);
86625   arg4 = &arg4_str;
86626   {
86627     try {
86628       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86629     } catch (std::out_of_range& e) {
86630       {
86631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86632       };
86633     } catch (std::exception& e) {
86634       {
86635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86636       };
86637     } catch (Dali::DaliException e) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86640       };
86641     } catch (...) {
86642       {
86643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86644       };
86645     }
86646   }
86647
86648
86649   //argout typemap for const std::string&
86650
86651
86652   //argout typemap for const std::string&
86653
86654 }
86655
86656
86657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86658   void * jresult ;
86659   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86660   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86661
86662   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86663   {
86664     try {
86665       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (Dali::DaliException e) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86677       };
86678     } catch (...) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86681       };
86682     }
86683   }
86684
86685   jresult = (void *)result;
86686   return jresult;
86687 }
86688
86689
86690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86691   int jresult ;
86692   int result;
86693
86694   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86695   jresult = (int)result;
86696   return jresult;
86697 }
86698
86699
86700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86701   int jresult ;
86702   int result;
86703
86704   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86705   jresult = (int)result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86711   int jresult ;
86712   int result;
86713
86714   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86715   jresult = (int)result;
86716   return jresult;
86717 }
86718
86719
86720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86721   int jresult ;
86722   int result;
86723
86724   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86725   jresult = (int)result;
86726   return jresult;
86727 }
86728
86729
86730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86731   int jresult ;
86732   int result;
86733
86734   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86735   jresult = (int)result;
86736   return jresult;
86737 }
86738
86739
86740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86741   int jresult ;
86742   int result;
86743
86744   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86745   jresult = (int)result;
86746   return jresult;
86747 }
86748
86749
86750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86751   int jresult ;
86752   int result;
86753
86754   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86755   jresult = (int)result;
86756   return jresult;
86757 }
86758
86759
86760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86761   int jresult ;
86762   int result;
86763
86764   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86765   jresult = (int)result;
86766   return jresult;
86767 }
86768
86769
86770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86771   int jresult ;
86772   int result;
86773
86774   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86775   jresult = (int)result;
86776   return jresult;
86777 }
86778
86779
86780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86781   int jresult ;
86782   int result;
86783
86784   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86785   jresult = (int)result;
86786   return jresult;
86787 }
86788
86789
86790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86791   int jresult ;
86792   int result;
86793
86794   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86795   jresult = (int)result;
86796   return jresult;
86797 }
86798
86799
86800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86801   int jresult ;
86802   int result;
86803
86804   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86805   jresult = (int)result;
86806   return jresult;
86807 }
86808
86809
86810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86811   int jresult ;
86812   int result;
86813
86814   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86815   jresult = (int)result;
86816   return jresult;
86817 }
86818
86819
86820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86821   int jresult ;
86822   int result;
86823
86824   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86825   jresult = (int)result;
86826   return jresult;
86827 }
86828
86829
86830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86831   int jresult ;
86832   int result;
86833
86834   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86835   jresult = (int)result;
86836   return jresult;
86837 }
86838
86839
86840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86841   void * jresult ;
86842   Dali::Toolkit::Slider::Property *result = 0 ;
86843
86844   {
86845     try {
86846       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86854       };
86855     } catch (Dali::DaliException e) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86858       };
86859     } catch (...) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86862       };
86863     }
86864   }
86865
86866   jresult = (void *)result;
86867   return jresult;
86868 }
86869
86870
86871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86872   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86873
86874   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86875   {
86876     try {
86877       delete arg1;
86878     } catch (std::out_of_range& e) {
86879       {
86880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86881       };
86882     } catch (std::exception& e) {
86883       {
86884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86885       };
86886     } catch (Dali::DaliException e) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86889       };
86890     } catch (...) {
86891       {
86892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86893       };
86894     }
86895   }
86896
86897 }
86898
86899
86900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86901   void * jresult ;
86902   Dali::Toolkit::Slider result;
86903
86904   {
86905     try {
86906       result = Dali::Toolkit::Slider::New();
86907     } catch (std::out_of_range& e) {
86908       {
86909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (std::exception& e) {
86912       {
86913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86914       };
86915     } catch (Dali::DaliException e) {
86916       {
86917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86918       };
86919     } catch (...) {
86920       {
86921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86922       };
86923     }
86924   }
86925
86926   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86927   return jresult;
86928 }
86929
86930
86931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86932   void * jresult ;
86933   Dali::Toolkit::Slider *result = 0 ;
86934
86935   {
86936     try {
86937       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86938     } catch (std::out_of_range& e) {
86939       {
86940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86941       };
86942     } catch (std::exception& e) {
86943       {
86944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86945       };
86946     } catch (Dali::DaliException e) {
86947       {
86948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86949       };
86950     } catch (...) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86953       };
86954     }
86955   }
86956
86957   jresult = (void *)result;
86958   return jresult;
86959 }
86960
86961
86962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86963   void * jresult ;
86964   Dali::Toolkit::Slider *arg1 = 0 ;
86965   Dali::Toolkit::Slider *result = 0 ;
86966
86967   arg1 = (Dali::Toolkit::Slider *)jarg1;
86968   if (!arg1) {
86969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86970     return 0;
86971   }
86972   {
86973     try {
86974       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86975     } catch (std::out_of_range& e) {
86976       {
86977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86978       };
86979     } catch (std::exception& e) {
86980       {
86981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86982       };
86983     } catch (Dali::DaliException e) {
86984       {
86985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86986       };
86987     } catch (...) {
86988       {
86989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86990       };
86991     }
86992   }
86993
86994   jresult = (void *)result;
86995   return jresult;
86996 }
86997
86998
86999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87000   void * jresult ;
87001   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87002   Dali::Toolkit::Slider *arg2 = 0 ;
87003   Dali::Toolkit::Slider *result = 0 ;
87004
87005   arg1 = (Dali::Toolkit::Slider *)jarg1;
87006   arg2 = (Dali::Toolkit::Slider *)jarg2;
87007   if (!arg2) {
87008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87009     return 0;
87010   }
87011   {
87012     try {
87013       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87014     } catch (std::out_of_range& e) {
87015       {
87016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87017       };
87018     } catch (std::exception& e) {
87019       {
87020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87021       };
87022     } catch (Dali::DaliException e) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87025       };
87026     } catch (...) {
87027       {
87028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87029       };
87030     }
87031   }
87032
87033   jresult = (void *)result;
87034   return jresult;
87035 }
87036
87037
87038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87039   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87040
87041   arg1 = (Dali::Toolkit::Slider *)jarg1;
87042   {
87043     try {
87044       delete arg1;
87045     } catch (std::out_of_range& e) {
87046       {
87047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87048       };
87049     } catch (std::exception& e) {
87050       {
87051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87052       };
87053     } catch (Dali::DaliException e) {
87054       {
87055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87056       };
87057     } catch (...) {
87058       {
87059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87060       };
87061     }
87062   }
87063
87064 }
87065
87066
87067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87068   void * jresult ;
87069   Dali::BaseHandle arg1 ;
87070   Dali::BaseHandle *argp1 ;
87071   Dali::Toolkit::Slider result;
87072
87073   argp1 = (Dali::BaseHandle *)jarg1;
87074   if (!argp1) {
87075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87076     return 0;
87077   }
87078   arg1 = *argp1;
87079   {
87080     try {
87081       result = Dali::Toolkit::Slider::DownCast(arg1);
87082     } catch (std::out_of_range& e) {
87083       {
87084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (std::exception& e) {
87087       {
87088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87089       };
87090     } catch (Dali::DaliException e) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87093       };
87094     } catch (...) {
87095       {
87096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87097       };
87098     }
87099   }
87100
87101   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87102   return jresult;
87103 }
87104
87105
87106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87107   void * jresult ;
87108   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87109   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87110
87111   arg1 = (Dali::Toolkit::Slider *)jarg1;
87112   {
87113     try {
87114       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87115     } catch (std::out_of_range& e) {
87116       {
87117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87118       };
87119     } catch (std::exception& e) {
87120       {
87121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87122       };
87123     } catch (Dali::DaliException e) {
87124       {
87125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87126       };
87127     } catch (...) {
87128       {
87129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87130       };
87131     }
87132   }
87133
87134   jresult = (void *)result;
87135   return jresult;
87136 }
87137
87138
87139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87140   void * jresult ;
87141   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87142   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87143
87144   arg1 = (Dali::Toolkit::Slider *)jarg1;
87145   {
87146     try {
87147       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87148     } catch (std::out_of_range& e) {
87149       {
87150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87151       };
87152     } catch (std::exception& e) {
87153       {
87154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87155       };
87156     } catch (Dali::DaliException e) {
87157       {
87158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87159       };
87160     } catch (...) {
87161       {
87162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87163       };
87164     }
87165   }
87166
87167   jresult = (void *)result;
87168   return jresult;
87169 }
87170
87171
87172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87173   void * jresult ;
87174   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87175   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87176
87177   arg1 = (Dali::Toolkit::Slider *)jarg1;
87178   {
87179     try {
87180       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87181     } catch (std::out_of_range& e) {
87182       {
87183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87184       };
87185     } catch (std::exception& e) {
87186       {
87187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87188       };
87189     } catch (Dali::DaliException e) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87192       };
87193     } catch (...) {
87194       {
87195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87196       };
87197     }
87198   }
87199
87200   jresult = (void *)result;
87201   return jresult;
87202 }
87203
87204
87205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87206   int jresult ;
87207   int result;
87208
87209   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87210   jresult = (int)result;
87211   return jresult;
87212 }
87213
87214
87215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87216   int jresult ;
87217   int result;
87218
87219   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87220   jresult = (int)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87226   int jresult ;
87227   int result;
87228
87229   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87230   jresult = (int)result;
87231   return jresult;
87232 }
87233
87234
87235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87236   int jresult ;
87237   int result;
87238
87239   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87240   jresult = (int)result;
87241   return jresult;
87242 }
87243
87244
87245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87246   int result;
87247
87248   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87249
87250   return result;
87251 }
87252
87253
87254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87255   void * jresult ;
87256   Dali::Toolkit::VideoView::Property *result = 0 ;
87257
87258   {
87259     try {
87260       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87261     } catch (std::out_of_range& e) {
87262       {
87263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87264       };
87265     } catch (std::exception& e) {
87266       {
87267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87268       };
87269     } catch (Dali::DaliException e) {
87270       {
87271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87272       };
87273     } catch (...) {
87274       {
87275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87276       };
87277     }
87278   }
87279
87280   jresult = (void *)result;
87281   return jresult;
87282 }
87283
87284
87285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87286   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87287
87288   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87289   {
87290     try {
87291       delete arg1;
87292     } catch (std::out_of_range& e) {
87293       {
87294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (std::exception& e) {
87297       {
87298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87299       };
87300     } catch (Dali::DaliException e) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87303       };
87304     } catch (...) {
87305       {
87306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87307       };
87308     }
87309   }
87310
87311 }
87312
87313
87314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87315   void * jresult ;
87316   Dali::Toolkit::VideoView result;
87317
87318   {
87319     try {
87320       result = Dali::Toolkit::VideoView::New();
87321     } catch (std::out_of_range& e) {
87322       {
87323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87324       };
87325     } catch (std::exception& e) {
87326       {
87327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87328       };
87329     } catch (Dali::DaliException e) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87332       };
87333     } catch (...) {
87334       {
87335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87336       };
87337     }
87338   }
87339
87340   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87341   return jresult;
87342 }
87343
87344
87345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87346   void * jresult ;
87347   std::string *arg1 = 0 ;
87348   Dali::Toolkit::VideoView result;
87349
87350   if (!jarg1) {
87351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87352     return 0;
87353   }
87354   std::string arg1_str(jarg1);
87355   arg1 = &arg1_str;
87356   {
87357     try {
87358       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87359     } catch (std::out_of_range& e) {
87360       {
87361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87362       };
87363     } catch (std::exception& e) {
87364       {
87365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87366       };
87367     } catch (Dali::DaliException e) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87370       };
87371     } catch (...) {
87372       {
87373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87374       };
87375     }
87376   }
87377
87378   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87379
87380   //argout typemap for const std::string&
87381
87382   return jresult;
87383 }
87384
87385
87386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87387   void * jresult ;
87388   Dali::Toolkit::VideoView *result = 0 ;
87389
87390   {
87391     try {
87392       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87393     } catch (std::out_of_range& e) {
87394       {
87395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87396       };
87397     } catch (std::exception& e) {
87398       {
87399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87400       };
87401     } catch (Dali::DaliException e) {
87402       {
87403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87404       };
87405     } catch (...) {
87406       {
87407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87408       };
87409     }
87410   }
87411
87412   jresult = (void *)result;
87413   return jresult;
87414 }
87415
87416
87417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87418   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87419
87420   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87421   {
87422     try {
87423       delete arg1;
87424     } catch (std::out_of_range& e) {
87425       {
87426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87427       };
87428     } catch (std::exception& e) {
87429       {
87430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87431       };
87432     } catch (Dali::DaliException e) {
87433       {
87434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87435       };
87436     } catch (...) {
87437       {
87438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87439       };
87440     }
87441   }
87442
87443 }
87444
87445
87446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87447   void * jresult ;
87448   Dali::Toolkit::VideoView *arg1 = 0 ;
87449   Dali::Toolkit::VideoView *result = 0 ;
87450
87451   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87452   if (!arg1) {
87453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87454     return 0;
87455   }
87456   {
87457     try {
87458       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87459     } catch (std::out_of_range& e) {
87460       {
87461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87462       };
87463     } catch (std::exception& e) {
87464       {
87465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87466       };
87467     } catch (Dali::DaliException e) {
87468       {
87469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87470       };
87471     } catch (...) {
87472       {
87473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87474       };
87475     }
87476   }
87477
87478   jresult = (void *)result;
87479   return jresult;
87480 }
87481
87482
87483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87484   void * jresult ;
87485   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87486   Dali::Toolkit::VideoView *arg2 = 0 ;
87487   Dali::Toolkit::VideoView *result = 0 ;
87488
87489   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87490   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87491   if (!arg2) {
87492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87493     return 0;
87494   }
87495   {
87496     try {
87497       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87498     } catch (std::out_of_range& e) {
87499       {
87500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87501       };
87502     } catch (std::exception& e) {
87503       {
87504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87505       };
87506     } catch (Dali::DaliException e) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87509       };
87510     } catch (...) {
87511       {
87512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87513       };
87514     }
87515   }
87516
87517   jresult = (void *)result;
87518   return jresult;
87519 }
87520
87521
87522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87523   void * jresult ;
87524   Dali::BaseHandle arg1 ;
87525   Dali::BaseHandle *argp1 ;
87526   Dali::Toolkit::VideoView result;
87527
87528   argp1 = (Dali::BaseHandle *)jarg1;
87529   if (!argp1) {
87530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87531     return 0;
87532   }
87533   arg1 = *argp1;
87534   {
87535     try {
87536       result = Dali::Toolkit::VideoView::DownCast(arg1);
87537     } catch (std::out_of_range& e) {
87538       {
87539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87540       };
87541     } catch (std::exception& e) {
87542       {
87543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87544       };
87545     } catch (Dali::DaliException e) {
87546       {
87547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87548       };
87549     } catch (...) {
87550       {
87551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87552       };
87553     }
87554   }
87555
87556   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87557   return jresult;
87558 }
87559
87560
87561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87562   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87563
87564   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87565   {
87566     try {
87567       (arg1)->Play();
87568     } catch (std::out_of_range& e) {
87569       {
87570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87571       };
87572     } catch (std::exception& e) {
87573       {
87574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87575       };
87576     } catch (Dali::DaliException e) {
87577       {
87578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87579       };
87580     } catch (...) {
87581       {
87582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87583       };
87584     }
87585   }
87586
87587 }
87588
87589
87590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87591   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87592
87593   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87594   {
87595     try {
87596       (arg1)->Pause();
87597     } catch (std::out_of_range& e) {
87598       {
87599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87600       };
87601     } catch (std::exception& e) {
87602       {
87603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87604       };
87605     } catch (Dali::DaliException e) {
87606       {
87607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87608       };
87609     } catch (...) {
87610       {
87611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87612       };
87613     }
87614   }
87615
87616 }
87617
87618
87619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87620   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87621
87622   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87623   {
87624     try {
87625       (arg1)->Stop();
87626     } catch (std::out_of_range& e) {
87627       {
87628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87629       };
87630     } catch (std::exception& e) {
87631       {
87632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87633       };
87634     } catch (Dali::DaliException e) {
87635       {
87636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87637       };
87638     } catch (...) {
87639       {
87640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87641       };
87642     }
87643   }
87644
87645 }
87646
87647
87648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87649   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87650   int arg2 ;
87651
87652   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87653   arg2 = (int)jarg2;
87654   {
87655     try {
87656       (arg1)->Forward(arg2);
87657     } catch (std::out_of_range& e) {
87658       {
87659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87660       };
87661     } catch (std::exception& e) {
87662       {
87663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87664       };
87665     } catch (Dali::DaliException e) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87668       };
87669     } catch (...) {
87670       {
87671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87672       };
87673     }
87674   }
87675
87676 }
87677
87678
87679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87680   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87681   int arg2 ;
87682
87683   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87684   arg2 = (int)jarg2;
87685   {
87686     try {
87687       (arg1)->Backward(arg2);
87688     } catch (std::out_of_range& e) {
87689       {
87690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (std::exception& e) {
87693       {
87694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87695       };
87696     } catch (Dali::DaliException e) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87699       };
87700     } catch (...) {
87701       {
87702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87703       };
87704     }
87705   }
87706
87707 }
87708
87709
87710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87711   void * jresult ;
87712   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87713   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87714
87715   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87716   {
87717     try {
87718       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87719     } catch (std::out_of_range& e) {
87720       {
87721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (std::exception& e) {
87724       {
87725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87726       };
87727     } catch (Dali::DaliException e) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87730       };
87731     } catch (...) {
87732       {
87733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87734       };
87735     }
87736   }
87737
87738   jresult = (void *)result;
87739   return jresult;
87740 }
87741
87742
87743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87744   int jresult ;
87745   int result;
87746
87747   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87748   jresult = (int)result;
87749   return jresult;
87750 }
87751
87752
87753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87754   int jresult ;
87755   int result;
87756
87757   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87758   jresult = (int)result;
87759   return jresult;
87760 }
87761
87762
87763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87764   int jresult ;
87765   int result;
87766
87767   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87768   jresult = (int)result;
87769   return jresult;
87770 }
87771
87772
87773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87774   int jresult ;
87775   int result;
87776
87777   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87778   jresult = (int)result;
87779   return jresult;
87780 }
87781
87782
87783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87784   int jresult ;
87785   int result;
87786
87787   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87788   jresult = (int)result;
87789   return jresult;
87790 }
87791
87792
87793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87794   int jresult ;
87795   int result;
87796
87797   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87798   jresult = (int)result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87804   int jresult ;
87805   int result;
87806
87807   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87808   jresult = (int)result;
87809   return jresult;
87810 }
87811
87812
87813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87814   int jresult ;
87815   int result;
87816
87817   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87818   jresult = (int)result;
87819   return jresult;
87820 }
87821
87822
87823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87824   int jresult ;
87825   int result;
87826
87827   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87828   jresult = (int)result;
87829   return jresult;
87830 }
87831
87832
87833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87834   int jresult ;
87835   int result;
87836
87837   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87838   jresult = (int)result;
87839   return jresult;
87840 }
87841
87842
87843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87844   int jresult ;
87845   int result;
87846
87847   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87848   jresult = (int)result;
87849   return jresult;
87850 }
87851
87852
87853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87854   int jresult ;
87855   int result;
87856
87857   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87858   jresult = (int)result;
87859   return jresult;
87860 }
87861
87862
87863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87864   int jresult ;
87865   int result;
87866
87867   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87868   jresult = (int)result;
87869   return jresult;
87870 }
87871
87872
87873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87874   int jresult ;
87875   int result;
87876
87877   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87878   jresult = (int)result;
87879   return jresult;
87880 }
87881
87882
87883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87884   int jresult ;
87885   int result;
87886
87887   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87888   jresult = (int)result;
87889   return jresult;
87890 }
87891
87892
87893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87894   int jresult ;
87895   int result;
87896
87897   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87898   jresult = (int)result;
87899   return jresult;
87900 }
87901
87902
87903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87904   int jresult ;
87905   int result;
87906
87907   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87908   jresult = (int)result;
87909   return jresult;
87910 }
87911
87912
87913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87914   int jresult ;
87915   int result;
87916
87917   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87918   jresult = (int)result;
87919   return jresult;
87920 }
87921
87922
87923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87924   int jresult ;
87925   int result;
87926
87927   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87928   jresult = (int)result;
87929   return jresult;
87930 }
87931
87932
87933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87934   int jresult ;
87935   int result;
87936
87937   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87938   jresult = (int)result;
87939   return jresult;
87940 }
87941
87942
87943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87944   int jresult ;
87945   int result;
87946
87947   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87948   jresult = (int)result;
87949   return jresult;
87950 }
87951
87952
87953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87954   void * jresult ;
87955   Dali::Toolkit::Popup::Property *result = 0 ;
87956
87957   {
87958     try {
87959       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87960     } catch (std::out_of_range& e) {
87961       {
87962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (std::exception& e) {
87965       {
87966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87967       };
87968     } catch (Dali::DaliException e) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87971       };
87972     } catch (...) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87975       };
87976     }
87977   }
87978
87979   jresult = (void *)result;
87980   return jresult;
87981 }
87982
87983
87984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87985   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87986
87987   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87988   {
87989     try {
87990       delete arg1;
87991     } catch (std::out_of_range& e) {
87992       {
87993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87994       };
87995     } catch (std::exception& e) {
87996       {
87997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87998       };
87999     } catch (Dali::DaliException e) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88002       };
88003     } catch (...) {
88004       {
88005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88006       };
88007     }
88008   }
88009
88010 }
88011
88012
88013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88014   void * jresult ;
88015   Dali::Toolkit::Popup *result = 0 ;
88016
88017   {
88018     try {
88019       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88020     } catch (std::out_of_range& e) {
88021       {
88022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88023       };
88024     } catch (std::exception& e) {
88025       {
88026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88027       };
88028     } catch (Dali::DaliException e) {
88029       {
88030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88031       };
88032     } catch (...) {
88033       {
88034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88035       };
88036     }
88037   }
88038
88039   jresult = (void *)result;
88040   return jresult;
88041 }
88042
88043
88044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88045   void * jresult ;
88046   Dali::Toolkit::Popup result;
88047
88048   {
88049     try {
88050       result = Dali::Toolkit::Popup::New();
88051     } catch (std::out_of_range& e) {
88052       {
88053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88054       };
88055     } catch (std::exception& e) {
88056       {
88057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88058       };
88059     } catch (Dali::DaliException e) {
88060       {
88061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88062       };
88063     } catch (...) {
88064       {
88065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88066       };
88067     }
88068   }
88069
88070   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88071   return jresult;
88072 }
88073
88074
88075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88076   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88077
88078   arg1 = (Dali::Toolkit::Popup *)jarg1;
88079   {
88080     try {
88081       delete arg1;
88082     } catch (std::out_of_range& e) {
88083       {
88084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (std::exception& e) {
88087       {
88088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88089       };
88090     } catch (Dali::DaliException e) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88093       };
88094     } catch (...) {
88095       {
88096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88097       };
88098     }
88099   }
88100
88101 }
88102
88103
88104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88105   void * jresult ;
88106   Dali::Toolkit::Popup *arg1 = 0 ;
88107   Dali::Toolkit::Popup *result = 0 ;
88108
88109   arg1 = (Dali::Toolkit::Popup *)jarg1;
88110   if (!arg1) {
88111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88112     return 0;
88113   }
88114   {
88115     try {
88116       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88117     } catch (std::out_of_range& e) {
88118       {
88119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (std::exception& e) {
88122       {
88123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88124       };
88125     } catch (Dali::DaliException e) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88128       };
88129     } catch (...) {
88130       {
88131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88132       };
88133     }
88134   }
88135
88136   jresult = (void *)result;
88137   return jresult;
88138 }
88139
88140
88141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88142   void * jresult ;
88143   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88144   Dali::Toolkit::Popup *arg2 = 0 ;
88145   Dali::Toolkit::Popup *result = 0 ;
88146
88147   arg1 = (Dali::Toolkit::Popup *)jarg1;
88148   arg2 = (Dali::Toolkit::Popup *)jarg2;
88149   if (!arg2) {
88150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88151     return 0;
88152   }
88153   {
88154     try {
88155       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88156     } catch (std::out_of_range& e) {
88157       {
88158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88159       };
88160     } catch (std::exception& e) {
88161       {
88162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88163       };
88164     } catch (Dali::DaliException e) {
88165       {
88166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88167       };
88168     } catch (...) {
88169       {
88170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88171       };
88172     }
88173   }
88174
88175   jresult = (void *)result;
88176   return jresult;
88177 }
88178
88179
88180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88181   void * jresult ;
88182   Dali::BaseHandle arg1 ;
88183   Dali::BaseHandle *argp1 ;
88184   Dali::Toolkit::Popup result;
88185
88186   argp1 = (Dali::BaseHandle *)jarg1;
88187   if (!argp1) {
88188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88189     return 0;
88190   }
88191   arg1 = *argp1;
88192   {
88193     try {
88194       result = Dali::Toolkit::Popup::DownCast(arg1);
88195     } catch (std::out_of_range& e) {
88196       {
88197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88198       };
88199     } catch (std::exception& e) {
88200       {
88201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88202       };
88203     } catch (Dali::DaliException e) {
88204       {
88205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88206       };
88207     } catch (...) {
88208       {
88209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88210       };
88211     }
88212   }
88213
88214   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88215   return jresult;
88216 }
88217
88218
88219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88220   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88221   Dali::Actor arg2 ;
88222   Dali::Actor *argp2 ;
88223
88224   arg1 = (Dali::Toolkit::Popup *)jarg1;
88225   argp2 = (Dali::Actor *)jarg2;
88226   if (!argp2) {
88227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88228     return ;
88229   }
88230   arg2 = *argp2;
88231   {
88232     try {
88233       (arg1)->SetTitle(arg2);
88234     } catch (std::out_of_range& e) {
88235       {
88236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (std::exception& e) {
88239       {
88240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88241       };
88242     } catch (Dali::DaliException e) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88245       };
88246     } catch (...) {
88247       {
88248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88249       };
88250     }
88251   }
88252
88253 }
88254
88255
88256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88257   void * jresult ;
88258   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88259   Dali::Actor result;
88260
88261   arg1 = (Dali::Toolkit::Popup *)jarg1;
88262   {
88263     try {
88264       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88265     } catch (std::out_of_range& e) {
88266       {
88267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88268       };
88269     } catch (std::exception& e) {
88270       {
88271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88272       };
88273     } catch (Dali::DaliException e) {
88274       {
88275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88276       };
88277     } catch (...) {
88278       {
88279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88280       };
88281     }
88282   }
88283
88284   jresult = new Dali::Actor((const Dali::Actor &)result);
88285   return jresult;
88286 }
88287
88288
88289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88290   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88291   Dali::Actor arg2 ;
88292   Dali::Actor *argp2 ;
88293
88294   arg1 = (Dali::Toolkit::Popup *)jarg1;
88295   argp2 = (Dali::Actor *)jarg2;
88296   if (!argp2) {
88297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88298     return ;
88299   }
88300   arg2 = *argp2;
88301   {
88302     try {
88303       (arg1)->SetContent(arg2);
88304     } catch (std::out_of_range& e) {
88305       {
88306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88307       };
88308     } catch (std::exception& e) {
88309       {
88310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88311       };
88312     } catch (Dali::DaliException e) {
88313       {
88314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88315       };
88316     } catch (...) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88319       };
88320     }
88321   }
88322
88323 }
88324
88325
88326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88327   void * jresult ;
88328   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88329   Dali::Actor result;
88330
88331   arg1 = (Dali::Toolkit::Popup *)jarg1;
88332   {
88333     try {
88334       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88335     } catch (std::out_of_range& e) {
88336       {
88337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88338       };
88339     } catch (std::exception& e) {
88340       {
88341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88342       };
88343     } catch (Dali::DaliException e) {
88344       {
88345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88346       };
88347     } catch (...) {
88348       {
88349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88350       };
88351     }
88352   }
88353
88354   jresult = new Dali::Actor((const Dali::Actor &)result);
88355   return jresult;
88356 }
88357
88358
88359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88360   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88361   Dali::Actor arg2 ;
88362   Dali::Actor *argp2 ;
88363
88364   arg1 = (Dali::Toolkit::Popup *)jarg1;
88365   argp2 = (Dali::Actor *)jarg2;
88366   if (!argp2) {
88367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88368     return ;
88369   }
88370   arg2 = *argp2;
88371   {
88372     try {
88373       (arg1)->SetFooter(arg2);
88374     } catch (std::out_of_range& e) {
88375       {
88376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88377       };
88378     } catch (std::exception& e) {
88379       {
88380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88381       };
88382     } catch (Dali::DaliException e) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88385       };
88386     } catch (...) {
88387       {
88388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88389       };
88390     }
88391   }
88392
88393 }
88394
88395
88396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88397   void * jresult ;
88398   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88399   Dali::Actor result;
88400
88401   arg1 = (Dali::Toolkit::Popup *)jarg1;
88402   {
88403     try {
88404       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88405     } catch (std::out_of_range& e) {
88406       {
88407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88408       };
88409     } catch (std::exception& e) {
88410       {
88411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88412       };
88413     } catch (Dali::DaliException e) {
88414       {
88415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88416       };
88417     } catch (...) {
88418       {
88419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88420       };
88421     }
88422   }
88423
88424   jresult = new Dali::Actor((const Dali::Actor &)result);
88425   return jresult;
88426 }
88427
88428
88429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88430   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88431   Dali::Toolkit::Popup::DisplayState arg2 ;
88432
88433   arg1 = (Dali::Toolkit::Popup *)jarg1;
88434   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88435   {
88436     try {
88437       (arg1)->SetDisplayState(arg2);
88438     } catch (std::out_of_range& e) {
88439       {
88440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88441       };
88442     } catch (std::exception& e) {
88443       {
88444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88445       };
88446     } catch (Dali::DaliException e) {
88447       {
88448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88449       };
88450     } catch (...) {
88451       {
88452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88453       };
88454     }
88455   }
88456
88457 }
88458
88459
88460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88461   int jresult ;
88462   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88463   Dali::Toolkit::Popup::DisplayState result;
88464
88465   arg1 = (Dali::Toolkit::Popup *)jarg1;
88466   {
88467     try {
88468       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88469     } catch (std::out_of_range& e) {
88470       {
88471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88472       };
88473     } catch (std::exception& e) {
88474       {
88475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88476       };
88477     } catch (Dali::DaliException e) {
88478       {
88479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88480       };
88481     } catch (...) {
88482       {
88483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88484       };
88485     }
88486   }
88487
88488   jresult = (int)result;
88489   return jresult;
88490 }
88491
88492
88493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88494   void * jresult ;
88495   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88496   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88497
88498   arg1 = (Dali::Toolkit::Popup *)jarg1;
88499   {
88500     try {
88501       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88502     } catch (std::out_of_range& e) {
88503       {
88504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88505       };
88506     } catch (std::exception& e) {
88507       {
88508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88509       };
88510     } catch (Dali::DaliException e) {
88511       {
88512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88513       };
88514     } catch (...) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88517       };
88518     }
88519   }
88520
88521   jresult = (void *)result;
88522   return jresult;
88523 }
88524
88525
88526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88527   void * jresult ;
88528   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88529   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88530
88531   arg1 = (Dali::Toolkit::Popup *)jarg1;
88532   {
88533     try {
88534       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88535     } catch (std::out_of_range& e) {
88536       {
88537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88538       };
88539     } catch (std::exception& e) {
88540       {
88541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88542       };
88543     } catch (Dali::DaliException e) {
88544       {
88545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88546       };
88547     } catch (...) {
88548       {
88549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88550       };
88551     }
88552   }
88553
88554   jresult = (void *)result;
88555   return jresult;
88556 }
88557
88558
88559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88560   void * jresult ;
88561   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88562   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88563
88564   arg1 = (Dali::Toolkit::Popup *)jarg1;
88565   {
88566     try {
88567       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88568     } catch (std::out_of_range& e) {
88569       {
88570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (std::exception& e) {
88573       {
88574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88575       };
88576     } catch (Dali::DaliException e) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88579       };
88580     } catch (...) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88583       };
88584     }
88585   }
88586
88587   jresult = (void *)result;
88588   return jresult;
88589 }
88590
88591
88592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88593   void * jresult ;
88594   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88595   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88596
88597   arg1 = (Dali::Toolkit::Popup *)jarg1;
88598   {
88599     try {
88600       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88601     } catch (std::out_of_range& e) {
88602       {
88603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (std::exception& e) {
88606       {
88607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88608       };
88609     } catch (Dali::DaliException e) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88612       };
88613     } catch (...) {
88614       {
88615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88616       };
88617     }
88618   }
88619
88620   jresult = (void *)result;
88621   return jresult;
88622 }
88623
88624
88625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88626   void * jresult ;
88627   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88628   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88629
88630   arg1 = (Dali::Toolkit::Popup *)jarg1;
88631   {
88632     try {
88633       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88634     } catch (std::out_of_range& e) {
88635       {
88636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88637       };
88638     } catch (std::exception& e) {
88639       {
88640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88641       };
88642     } catch (Dali::DaliException e) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88645       };
88646     } catch (...) {
88647       {
88648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88649       };
88650     }
88651   }
88652
88653   jresult = (void *)result;
88654   return jresult;
88655 }
88656
88657
88658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88659   int jresult ;
88660   int result;
88661
88662   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88663   jresult = (int)result;
88664   return jresult;
88665 }
88666
88667
88668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88669   int jresult ;
88670   int result;
88671
88672   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88673   jresult = (int)result;
88674   return jresult;
88675 }
88676
88677
88678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88679   int jresult ;
88680   int result;
88681
88682   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88683   jresult = (int)result;
88684   return jresult;
88685 }
88686
88687
88688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88689   int jresult ;
88690   int result;
88691
88692   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88693   jresult = (int)result;
88694   return jresult;
88695 }
88696
88697
88698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88699   int jresult ;
88700   int result;
88701
88702   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88703   jresult = (int)result;
88704   return jresult;
88705 }
88706
88707
88708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88709   int jresult ;
88710   int result;
88711
88712   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88713   jresult = (int)result;
88714   return jresult;
88715 }
88716
88717
88718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88719   int jresult ;
88720   int result;
88721
88722   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88723   jresult = (int)result;
88724   return jresult;
88725 }
88726
88727
88728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88729   int jresult ;
88730   int result;
88731
88732   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88733   jresult = (int)result;
88734   return jresult;
88735 }
88736
88737
88738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88739   int jresult ;
88740   int result;
88741
88742   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88743   jresult = (int)result;
88744   return jresult;
88745 }
88746
88747
88748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88749   void * jresult ;
88750   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88751
88752   {
88753     try {
88754       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88755     } catch (std::out_of_range& e) {
88756       {
88757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (std::exception& e) {
88760       {
88761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (Dali::DaliException e) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88770       };
88771     }
88772   }
88773
88774   jresult = (void *)result;
88775   return jresult;
88776 }
88777
88778
88779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88780   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88781
88782   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88783   {
88784     try {
88785       delete arg1;
88786     } catch (std::out_of_range& e) {
88787       {
88788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88789       };
88790     } catch (std::exception& e) {
88791       {
88792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88793       };
88794     } catch (Dali::DaliException e) {
88795       {
88796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88797       };
88798     } catch (...) {
88799       {
88800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88801       };
88802     }
88803   }
88804
88805 }
88806
88807
88808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88809   void * jresult ;
88810   Dali::Toolkit::ProgressBar result;
88811
88812   {
88813     try {
88814       result = Dali::Toolkit::ProgressBar::New();
88815     } catch (std::out_of_range& e) {
88816       {
88817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88818       };
88819     } catch (std::exception& e) {
88820       {
88821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88822       };
88823     } catch (Dali::DaliException e) {
88824       {
88825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88826       };
88827     } catch (...) {
88828       {
88829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88830       };
88831     }
88832   }
88833
88834   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88835   return jresult;
88836 }
88837
88838
88839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88840   void * jresult ;
88841   Dali::Toolkit::ProgressBar *result = 0 ;
88842
88843   {
88844     try {
88845       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88846     } catch (std::out_of_range& e) {
88847       {
88848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (std::exception& e) {
88851       {
88852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88853       };
88854     } catch (Dali::DaliException e) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88857       };
88858     } catch (...) {
88859       {
88860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88861       };
88862     }
88863   }
88864
88865   jresult = (void *)result;
88866   return jresult;
88867 }
88868
88869
88870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88871   void * jresult ;
88872   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88873   Dali::Toolkit::ProgressBar *result = 0 ;
88874
88875   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88876   if (!arg1) {
88877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88878     return 0;
88879   }
88880   {
88881     try {
88882       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88883     } catch (std::out_of_range& e) {
88884       {
88885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88886       };
88887     } catch (std::exception& e) {
88888       {
88889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88890       };
88891     } catch (Dali::DaliException e) {
88892       {
88893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88894       };
88895     } catch (...) {
88896       {
88897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88898       };
88899     }
88900   }
88901
88902   jresult = (void *)result;
88903   return jresult;
88904 }
88905
88906
88907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88908   void * jresult ;
88909   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88910   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88911   Dali::Toolkit::ProgressBar *result = 0 ;
88912
88913   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88914   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88915   if (!arg2) {
88916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88917     return 0;
88918   }
88919   {
88920     try {
88921       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88922     } catch (std::out_of_range& e) {
88923       {
88924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88925       };
88926     } catch (std::exception& e) {
88927       {
88928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88929       };
88930     } catch (Dali::DaliException e) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88933       };
88934     } catch (...) {
88935       {
88936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88937       };
88938     }
88939   }
88940
88941   jresult = (void *)result;
88942   return jresult;
88943 }
88944
88945
88946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88947   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88948
88949   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88950   {
88951     try {
88952       delete arg1;
88953     } catch (std::out_of_range& e) {
88954       {
88955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88956       };
88957     } catch (std::exception& e) {
88958       {
88959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88960       };
88961     } catch (Dali::DaliException e) {
88962       {
88963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88964       };
88965     } catch (...) {
88966       {
88967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88968       };
88969     }
88970   }
88971
88972 }
88973
88974
88975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88976   void * jresult ;
88977   Dali::BaseHandle arg1 ;
88978   Dali::BaseHandle *argp1 ;
88979   Dali::Toolkit::ProgressBar result;
88980
88981   argp1 = (Dali::BaseHandle *)jarg1;
88982   if (!argp1) {
88983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88984     return 0;
88985   }
88986   arg1 = *argp1;
88987   {
88988     try {
88989       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88990     } catch (std::out_of_range& e) {
88991       {
88992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88993       };
88994     } catch (std::exception& e) {
88995       {
88996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88997       };
88998     } catch (Dali::DaliException e) {
88999       {
89000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89001       };
89002     } catch (...) {
89003       {
89004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89005       };
89006     }
89007   }
89008
89009   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89010   return jresult;
89011 }
89012
89013
89014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89015   void * jresult ;
89016   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89017   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89018
89019   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89020   {
89021     try {
89022       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89023     } catch (std::out_of_range& e) {
89024       {
89025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89026       };
89027     } catch (std::exception& e) {
89028       {
89029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89030       };
89031     } catch (Dali::DaliException e) {
89032       {
89033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89034       };
89035     } catch (...) {
89036       {
89037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89038       };
89039     }
89040   }
89041
89042   jresult = (void *)result;
89043   return jresult;
89044 }
89045
89046
89047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89048   void * jresult ;
89049   Dali::Toolkit::GaussianBlurView *result = 0 ;
89050
89051   {
89052     try {
89053       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89054     } catch (std::out_of_range& e) {
89055       {
89056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89057       };
89058     } catch (std::exception& e) {
89059       {
89060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89061       };
89062     } catch (Dali::DaliException e) {
89063       {
89064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89065       };
89066     } catch (...) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89069       };
89070     }
89071   }
89072
89073   jresult = (void *)result;
89074   return jresult;
89075 }
89076
89077
89078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89079   void * jresult ;
89080   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89081   Dali::Toolkit::GaussianBlurView *result = 0 ;
89082
89083   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89084   if (!arg1) {
89085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89086     return 0;
89087   }
89088   {
89089     try {
89090       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89091     } catch (std::out_of_range& e) {
89092       {
89093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89094       };
89095     } catch (std::exception& e) {
89096       {
89097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (Dali::DaliException e) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89102       };
89103     } catch (...) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89106       };
89107     }
89108   }
89109
89110   jresult = (void *)result;
89111   return jresult;
89112 }
89113
89114
89115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89116   void * jresult ;
89117   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89118   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89119   Dali::Toolkit::GaussianBlurView *result = 0 ;
89120
89121   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89122   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89123   if (!arg2) {
89124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89125     return 0;
89126   }
89127   {
89128     try {
89129       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89130     } catch (std::out_of_range& e) {
89131       {
89132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (std::exception& e) {
89135       {
89136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89137       };
89138     } catch (Dali::DaliException e) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89141       };
89142     } catch (...) {
89143       {
89144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89145       };
89146     }
89147   }
89148
89149   jresult = (void *)result;
89150   return jresult;
89151 }
89152
89153
89154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89155   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89156
89157   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89158   {
89159     try {
89160       delete arg1;
89161     } catch (std::out_of_range& e) {
89162       {
89163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89164       };
89165     } catch (std::exception& e) {
89166       {
89167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89168       };
89169     } catch (Dali::DaliException e) {
89170       {
89171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89172       };
89173     } catch (...) {
89174       {
89175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89176       };
89177     }
89178   }
89179
89180 }
89181
89182
89183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89184   void * jresult ;
89185   Dali::BaseHandle arg1 ;
89186   Dali::BaseHandle *argp1 ;
89187   Dali::Toolkit::GaussianBlurView result;
89188
89189   argp1 = (Dali::BaseHandle *)jarg1;
89190   if (!argp1) {
89191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89192     return 0;
89193   }
89194   arg1 = *argp1;
89195   {
89196     try {
89197       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89198     } catch (std::out_of_range& e) {
89199       {
89200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (std::exception& e) {
89203       {
89204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89205       };
89206     } catch (Dali::DaliException e) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89209       };
89210     } catch (...) {
89211       {
89212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89213       };
89214     }
89215   }
89216
89217   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89218   return jresult;
89219 }
89220
89221
89222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89223   void * jresult ;
89224   Dali::Toolkit::GaussianBlurView result;
89225
89226   {
89227     try {
89228       result = Dali::Toolkit::GaussianBlurView::New();
89229     } catch (std::out_of_range& e) {
89230       {
89231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89232       };
89233     } catch (std::exception& e) {
89234       {
89235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89236       };
89237     } catch (Dali::DaliException e) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89240       };
89241     } catch (...) {
89242       {
89243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89244       };
89245     }
89246   }
89247
89248   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89249   return jresult;
89250 }
89251
89252
89253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89254   void * jresult ;
89255   unsigned int arg1 ;
89256   float arg2 ;
89257   Dali::Pixel::Format arg3 ;
89258   float arg4 ;
89259   float arg5 ;
89260   bool arg6 ;
89261   Dali::Toolkit::GaussianBlurView result;
89262
89263   arg1 = (unsigned int)jarg1;
89264   arg2 = (float)jarg2;
89265   arg3 = (Dali::Pixel::Format)jarg3;
89266   arg4 = (float)jarg4;
89267   arg5 = (float)jarg5;
89268   arg6 = jarg6 ? true : false;
89269   {
89270     try {
89271       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89272     } catch (std::out_of_range& e) {
89273       {
89274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89275       };
89276     } catch (std::exception& e) {
89277       {
89278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89279       };
89280     } catch (Dali::DaliException e) {
89281       {
89282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89283       };
89284     } catch (...) {
89285       {
89286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89287       };
89288     }
89289   }
89290
89291   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89292   return jresult;
89293 }
89294
89295
89296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89297   void * jresult ;
89298   unsigned int arg1 ;
89299   float arg2 ;
89300   Dali::Pixel::Format arg3 ;
89301   float arg4 ;
89302   float arg5 ;
89303   Dali::Toolkit::GaussianBlurView result;
89304
89305   arg1 = (unsigned int)jarg1;
89306   arg2 = (float)jarg2;
89307   arg3 = (Dali::Pixel::Format)jarg3;
89308   arg4 = (float)jarg4;
89309   arg5 = (float)jarg5;
89310   {
89311     try {
89312       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89313     } catch (std::out_of_range& e) {
89314       {
89315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89316       };
89317     } catch (std::exception& e) {
89318       {
89319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89320       };
89321     } catch (Dali::DaliException e) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89324       };
89325     } catch (...) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89328       };
89329     }
89330   }
89331
89332   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89333   return jresult;
89334 }
89335
89336
89337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89338   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89339   Dali::Actor arg2 ;
89340   Dali::Actor *argp2 ;
89341
89342   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89343   argp2 = (Dali::Actor *)jarg2;
89344   if (!argp2) {
89345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89346     return ;
89347   }
89348   arg2 = *argp2;
89349   {
89350     try {
89351       (arg1)->Add(arg2);
89352     } catch (std::out_of_range& e) {
89353       {
89354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89355       };
89356     } catch (std::exception& e) {
89357       {
89358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89359       };
89360     } catch (Dali::DaliException e) {
89361       {
89362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89363       };
89364     } catch (...) {
89365       {
89366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89367       };
89368     }
89369   }
89370
89371 }
89372
89373
89374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89375   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89376   Dali::Actor arg2 ;
89377   Dali::Actor *argp2 ;
89378
89379   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89380   argp2 = (Dali::Actor *)jarg2;
89381   if (!argp2) {
89382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89383     return ;
89384   }
89385   arg2 = *argp2;
89386   {
89387     try {
89388       (arg1)->Remove(arg2);
89389     } catch (std::out_of_range& e) {
89390       {
89391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89392       };
89393     } catch (std::exception& e) {
89394       {
89395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89396       };
89397     } catch (Dali::DaliException e) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89400       };
89401     } catch (...) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89404       };
89405     }
89406   }
89407
89408 }
89409
89410
89411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89412   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89413
89414   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89415   {
89416     try {
89417       (arg1)->Activate();
89418     } catch (std::out_of_range& e) {
89419       {
89420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (std::exception& e) {
89423       {
89424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (Dali::DaliException e) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89429       };
89430     } catch (...) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89433       };
89434     }
89435   }
89436
89437 }
89438
89439
89440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89441   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89442
89443   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89444   {
89445     try {
89446       (arg1)->ActivateOnce();
89447     } catch (std::out_of_range& e) {
89448       {
89449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89450       };
89451     } catch (std::exception& e) {
89452       {
89453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89454       };
89455     } catch (Dali::DaliException e) {
89456       {
89457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89458       };
89459     } catch (...) {
89460       {
89461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89462       };
89463     }
89464   }
89465
89466 }
89467
89468
89469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89470   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89471
89472   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89473   {
89474     try {
89475       (arg1)->Deactivate();
89476     } catch (std::out_of_range& e) {
89477       {
89478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (std::exception& e) {
89481       {
89482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89483       };
89484     } catch (Dali::DaliException e) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89487       };
89488     } catch (...) {
89489       {
89490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89491       };
89492     }
89493   }
89494
89495 }
89496
89497
89498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89499   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89500   Dali::Image arg2 ;
89501   Dali::FrameBufferImage arg3 ;
89502   Dali::Image *argp2 ;
89503   Dali::FrameBufferImage *argp3 ;
89504
89505   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89506   argp2 = (Dali::Image *)jarg2;
89507   if (!argp2) {
89508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89509     return ;
89510   }
89511   arg2 = *argp2;
89512   argp3 = (Dali::FrameBufferImage *)jarg3;
89513   if (!argp3) {
89514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89515     return ;
89516   }
89517   arg3 = *argp3;
89518   {
89519     try {
89520       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89521     } catch (std::out_of_range& e) {
89522       {
89523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89524       };
89525     } catch (std::exception& e) {
89526       {
89527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89528       };
89529     } catch (Dali::DaliException e) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89532       };
89533     } catch (...) {
89534       {
89535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89536       };
89537     }
89538   }
89539
89540 }
89541
89542
89543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89544   int jresult ;
89545   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89546   Dali::Property::Index result;
89547
89548   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89549   {
89550     try {
89551       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89552     } catch (std::out_of_range& e) {
89553       {
89554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89555       };
89556     } catch (std::exception& e) {
89557       {
89558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89559       };
89560     } catch (Dali::DaliException e) {
89561       {
89562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89563       };
89564     } catch (...) {
89565       {
89566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89567       };
89568     }
89569   }
89570
89571   jresult = result;
89572   return jresult;
89573 }
89574
89575
89576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89577   void * jresult ;
89578   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89579   Dali::FrameBufferImage result;
89580
89581   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89582   {
89583     try {
89584       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89585     } catch (std::out_of_range& e) {
89586       {
89587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (std::exception& e) {
89590       {
89591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89592       };
89593     } catch (Dali::DaliException e) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89596       };
89597     } catch (...) {
89598       {
89599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89600       };
89601     }
89602   }
89603
89604   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89605   return jresult;
89606 }
89607
89608
89609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89610   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89611   Dali::Vector4 *arg2 = 0 ;
89612
89613   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89614   arg2 = (Dali::Vector4 *)jarg2;
89615   if (!arg2) {
89616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89617     return ;
89618   }
89619   {
89620     try {
89621       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89622     } catch (std::out_of_range& e) {
89623       {
89624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89625       };
89626     } catch (std::exception& e) {
89627       {
89628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89629       };
89630     } catch (Dali::DaliException e) {
89631       {
89632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89633       };
89634     } catch (...) {
89635       {
89636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89637       };
89638     }
89639   }
89640
89641 }
89642
89643
89644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89645   void * jresult ;
89646   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89647   Dali::Vector4 result;
89648
89649   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89650   {
89651     try {
89652       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89653     } catch (std::out_of_range& e) {
89654       {
89655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89656       };
89657     } catch (std::exception& e) {
89658       {
89659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89660       };
89661     } catch (Dali::DaliException e) {
89662       {
89663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89664       };
89665     } catch (...) {
89666       {
89667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89668       };
89669     }
89670   }
89671
89672   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89673   return jresult;
89674 }
89675
89676
89677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89678   void * jresult ;
89679   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89680   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89681
89682   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89683   {
89684     try {
89685       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89686     } catch (std::out_of_range& e) {
89687       {
89688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89689       };
89690     } catch (std::exception& e) {
89691       {
89692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89693       };
89694     } catch (Dali::DaliException e) {
89695       {
89696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89697       };
89698     } catch (...) {
89699       {
89700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89701       };
89702     }
89703   }
89704
89705   jresult = (void *)result;
89706   return jresult;
89707 }
89708
89709
89710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89711   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89712
89713   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89714   {
89715     try {
89716       delete arg1;
89717     } catch (std::out_of_range& e) {
89718       {
89719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89720       };
89721     } catch (std::exception& e) {
89722       {
89723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89724       };
89725     } catch (Dali::DaliException e) {
89726       {
89727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89728       };
89729     } catch (...) {
89730       {
89731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89732       };
89733     }
89734   }
89735
89736 }
89737
89738
89739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89740   unsigned int jresult ;
89741   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89742   unsigned int result;
89743
89744   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89745   {
89746     try {
89747       result = (unsigned int)(arg1)->GetNumberOfPages();
89748     } catch (std::out_of_range& e) {
89749       {
89750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89751       };
89752     } catch (std::exception& e) {
89753       {
89754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89755       };
89756     } catch (Dali::DaliException e) {
89757       {
89758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89759       };
89760     } catch (...) {
89761       {
89762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89763       };
89764     }
89765   }
89766
89767   jresult = result;
89768   return jresult;
89769 }
89770
89771
89772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89773   void * jresult ;
89774   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89775   unsigned int arg2 ;
89776   Dali::Texture result;
89777
89778   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89779   arg2 = (unsigned int)jarg2;
89780   {
89781     try {
89782       result = (arg1)->NewPage(arg2);
89783     } catch (std::out_of_range& e) {
89784       {
89785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89786       };
89787     } catch (std::exception& e) {
89788       {
89789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89790       };
89791     } catch (Dali::DaliException e) {
89792       {
89793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89794       };
89795     } catch (...) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89798       };
89799     }
89800   }
89801
89802   jresult = new Dali::Texture((const Dali::Texture &)result);
89803   return jresult;
89804 }
89805
89806
89807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89808   int jresult ;
89809   int result;
89810
89811   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89812   jresult = (int)result;
89813   return jresult;
89814 }
89815
89816
89817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89818   int jresult ;
89819   int result;
89820
89821   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89822   jresult = (int)result;
89823   return jresult;
89824 }
89825
89826
89827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89828   int jresult ;
89829   int result;
89830
89831   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89832   jresult = (int)result;
89833   return jresult;
89834 }
89835
89836
89837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89838   void * jresult ;
89839   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89840
89841   {
89842     try {
89843       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89844     } catch (std::out_of_range& e) {
89845       {
89846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89847       };
89848     } catch (std::exception& e) {
89849       {
89850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89851       };
89852     } catch (Dali::DaliException e) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89855       };
89856     } catch (...) {
89857       {
89858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89859       };
89860     }
89861   }
89862
89863   jresult = (void *)result;
89864   return jresult;
89865 }
89866
89867
89868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89869   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89870
89871   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89872   {
89873     try {
89874       delete arg1;
89875     } catch (std::out_of_range& e) {
89876       {
89877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (std::exception& e) {
89880       {
89881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (Dali::DaliException e) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89886       };
89887     } catch (...) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89890       };
89891     }
89892   }
89893
89894 }
89895
89896
89897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89898   void * jresult ;
89899   Dali::Toolkit::PageTurnView *result = 0 ;
89900
89901   {
89902     try {
89903       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89904     } catch (std::out_of_range& e) {
89905       {
89906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89907       };
89908     } catch (std::exception& e) {
89909       {
89910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89911       };
89912     } catch (Dali::DaliException e) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89915       };
89916     } catch (...) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89919       };
89920     }
89921   }
89922
89923   jresult = (void *)result;
89924   return jresult;
89925 }
89926
89927
89928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89929   void * jresult ;
89930   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89931   Dali::Toolkit::PageTurnView *result = 0 ;
89932
89933   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89934   if (!arg1) {
89935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89936     return 0;
89937   }
89938   {
89939     try {
89940       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89941     } catch (std::out_of_range& e) {
89942       {
89943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89944       };
89945     } catch (std::exception& e) {
89946       {
89947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89948       };
89949     } catch (Dali::DaliException e) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89952       };
89953     } catch (...) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89956       };
89957     }
89958   }
89959
89960   jresult = (void *)result;
89961   return jresult;
89962 }
89963
89964
89965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89966   void * jresult ;
89967   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89968   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89969   Dali::Toolkit::PageTurnView *result = 0 ;
89970
89971   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89972   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89973   if (!arg2) {
89974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89975     return 0;
89976   }
89977   {
89978     try {
89979       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89980     } catch (std::out_of_range& e) {
89981       {
89982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89983       };
89984     } catch (std::exception& e) {
89985       {
89986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89987       };
89988     } catch (Dali::DaliException e) {
89989       {
89990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89991       };
89992     } catch (...) {
89993       {
89994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89995       };
89996     }
89997   }
89998
89999   jresult = (void *)result;
90000   return jresult;
90001 }
90002
90003
90004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90005   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90006
90007   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90008   {
90009     try {
90010       delete arg1;
90011     } catch (std::out_of_range& e) {
90012       {
90013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (std::exception& e) {
90016       {
90017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90018       };
90019     } catch (Dali::DaliException e) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90022       };
90023     } catch (...) {
90024       {
90025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90026       };
90027     }
90028   }
90029
90030 }
90031
90032
90033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90034   void * jresult ;
90035   Dali::BaseHandle arg1 ;
90036   Dali::BaseHandle *argp1 ;
90037   Dali::Toolkit::PageTurnView result;
90038
90039   argp1 = (Dali::BaseHandle *)jarg1;
90040   if (!argp1) {
90041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90042     return 0;
90043   }
90044   arg1 = *argp1;
90045   {
90046     try {
90047       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90063       };
90064     }
90065   }
90066
90067   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90068   return jresult;
90069 }
90070
90071
90072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90073   void * jresult ;
90074   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90075   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90076
90077   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90078   {
90079     try {
90080       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90081     } catch (std::out_of_range& e) {
90082       {
90083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (std::exception& e) {
90086       {
90087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90088       };
90089     } catch (Dali::DaliException e) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90092       };
90093     } catch (...) {
90094       {
90095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90096       };
90097     }
90098   }
90099
90100   jresult = (void *)result;
90101   return jresult;
90102 }
90103
90104
90105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90106   void * jresult ;
90107   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90108   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90109
90110   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90111   {
90112     try {
90113       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90114     } catch (std::out_of_range& e) {
90115       {
90116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (std::exception& e) {
90119       {
90120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90121       };
90122     } catch (Dali::DaliException e) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90125       };
90126     } catch (...) {
90127       {
90128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90129       };
90130     }
90131   }
90132
90133   jresult = (void *)result;
90134   return jresult;
90135 }
90136
90137
90138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90139   void * jresult ;
90140   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90141   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90142
90143   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90144   {
90145     try {
90146       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90147     } catch (std::out_of_range& e) {
90148       {
90149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (std::exception& e) {
90152       {
90153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90154       };
90155     } catch (Dali::DaliException e) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90158       };
90159     } catch (...) {
90160       {
90161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90162       };
90163     }
90164   }
90165
90166   jresult = (void *)result;
90167   return jresult;
90168 }
90169
90170
90171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90172   void * jresult ;
90173   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90174   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90175
90176   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90177   {
90178     try {
90179       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90180     } catch (std::out_of_range& e) {
90181       {
90182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90183       };
90184     } catch (std::exception& e) {
90185       {
90186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90187       };
90188     } catch (Dali::DaliException e) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90191       };
90192     } catch (...) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90195       };
90196     }
90197   }
90198
90199   jresult = (void *)result;
90200   return jresult;
90201 }
90202
90203
90204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90205   void * jresult ;
90206   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90207
90208   {
90209     try {
90210       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90211     } catch (std::out_of_range& e) {
90212       {
90213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90214       };
90215     } catch (std::exception& e) {
90216       {
90217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90218       };
90219     } catch (Dali::DaliException e) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90222       };
90223     } catch (...) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90226       };
90227     }
90228   }
90229
90230   jresult = (void *)result;
90231   return jresult;
90232 }
90233
90234
90235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90236   void * jresult ;
90237   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90238   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90239
90240   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90241   if (!arg1) {
90242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90243     return 0;
90244   }
90245   {
90246     try {
90247       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90248     } catch (std::out_of_range& e) {
90249       {
90250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90251       };
90252     } catch (std::exception& e) {
90253       {
90254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90255       };
90256     } catch (Dali::DaliException e) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90259       };
90260     } catch (...) {
90261       {
90262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90263       };
90264     }
90265   }
90266
90267   jresult = (void *)result;
90268   return jresult;
90269 }
90270
90271
90272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90273   void * jresult ;
90274   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90275   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90276   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90277
90278   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90279   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90280   if (!arg2) {
90281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90282     return 0;
90283   }
90284   {
90285     try {
90286       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90287     } catch (std::out_of_range& e) {
90288       {
90289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90290       };
90291     } catch (std::exception& e) {
90292       {
90293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90294       };
90295     } catch (Dali::DaliException e) {
90296       {
90297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90298       };
90299     } catch (...) {
90300       {
90301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90302       };
90303     }
90304   }
90305
90306   jresult = (void *)result;
90307   return jresult;
90308 }
90309
90310
90311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90312   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90313
90314   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90315   {
90316     try {
90317       delete arg1;
90318     } catch (std::out_of_range& e) {
90319       {
90320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90321       };
90322     } catch (std::exception& e) {
90323       {
90324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90325       };
90326     } catch (Dali::DaliException e) {
90327       {
90328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90329       };
90330     } catch (...) {
90331       {
90332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90333       };
90334     }
90335   }
90336
90337 }
90338
90339
90340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90341   void * jresult ;
90342   Dali::Toolkit::PageFactory *arg1 = 0 ;
90343   Dali::Vector2 *arg2 = 0 ;
90344   Dali::Toolkit::PageTurnLandscapeView result;
90345
90346   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90347   if (!arg1) {
90348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90349     return 0;
90350   }
90351   arg2 = (Dali::Vector2 *)jarg2;
90352   if (!arg2) {
90353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90354     return 0;
90355   }
90356   {
90357     try {
90358       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90359     } catch (std::out_of_range& e) {
90360       {
90361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (std::exception& e) {
90364       {
90365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90366       };
90367     } catch (Dali::DaliException e) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90370       };
90371     } catch (...) {
90372       {
90373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90374       };
90375     }
90376   }
90377
90378   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90379   return jresult;
90380 }
90381
90382
90383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90384   void * jresult ;
90385   Dali::BaseHandle arg1 ;
90386   Dali::BaseHandle *argp1 ;
90387   Dali::Toolkit::PageTurnLandscapeView result;
90388
90389   argp1 = (Dali::BaseHandle *)jarg1;
90390   if (!argp1) {
90391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90392     return 0;
90393   }
90394   arg1 = *argp1;
90395   {
90396     try {
90397       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90398     } catch (std::out_of_range& e) {
90399       {
90400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (std::exception& e) {
90403       {
90404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90405       };
90406     } catch (Dali::DaliException e) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90409       };
90410     } catch (...) {
90411       {
90412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90413       };
90414     }
90415   }
90416
90417   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90418   return jresult;
90419 }
90420
90421
90422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90423   void * jresult ;
90424   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90425
90426   {
90427     try {
90428       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90429     } catch (std::out_of_range& e) {
90430       {
90431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90432       };
90433     } catch (std::exception& e) {
90434       {
90435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90436       };
90437     } catch (Dali::DaliException e) {
90438       {
90439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90440       };
90441     } catch (...) {
90442       {
90443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90444       };
90445     }
90446   }
90447
90448   jresult = (void *)result;
90449   return jresult;
90450 }
90451
90452
90453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90454   void * jresult ;
90455   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90456   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90457
90458   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90459   if (!arg1) {
90460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90461     return 0;
90462   }
90463   {
90464     try {
90465       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90466     } catch (std::out_of_range& e) {
90467       {
90468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (std::exception& e) {
90471       {
90472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90473       };
90474     } catch (Dali::DaliException e) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90477       };
90478     } catch (...) {
90479       {
90480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90481       };
90482     }
90483   }
90484
90485   jresult = (void *)result;
90486   return jresult;
90487 }
90488
90489
90490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90491   void * jresult ;
90492   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90493   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90494   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90495
90496   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90497   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90498   if (!arg2) {
90499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90500     return 0;
90501   }
90502   {
90503     try {
90504       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90505     } catch (std::out_of_range& e) {
90506       {
90507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90508       };
90509     } catch (std::exception& e) {
90510       {
90511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90512       };
90513     } catch (Dali::DaliException e) {
90514       {
90515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90516       };
90517     } catch (...) {
90518       {
90519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90520       };
90521     }
90522   }
90523
90524   jresult = (void *)result;
90525   return jresult;
90526 }
90527
90528
90529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90530   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90531
90532   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90533   {
90534     try {
90535       delete arg1;
90536     } catch (std::out_of_range& e) {
90537       {
90538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90539       };
90540     } catch (std::exception& e) {
90541       {
90542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90543       };
90544     } catch (Dali::DaliException e) {
90545       {
90546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90547       };
90548     } catch (...) {
90549       {
90550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90551       };
90552     }
90553   }
90554
90555 }
90556
90557
90558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90559   void * jresult ;
90560   Dali::Toolkit::PageFactory *arg1 = 0 ;
90561   Dali::Vector2 *arg2 = 0 ;
90562   Dali::Toolkit::PageTurnPortraitView result;
90563
90564   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90565   if (!arg1) {
90566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90567     return 0;
90568   }
90569   arg2 = (Dali::Vector2 *)jarg2;
90570   if (!arg2) {
90571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90572     return 0;
90573   }
90574   {
90575     try {
90576       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90577     } catch (std::out_of_range& e) {
90578       {
90579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (std::exception& e) {
90582       {
90583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (Dali::DaliException e) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90588       };
90589     } catch (...) {
90590       {
90591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90592       };
90593     }
90594   }
90595
90596   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90597   return jresult;
90598 }
90599
90600
90601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90602   void * jresult ;
90603   Dali::BaseHandle arg1 ;
90604   Dali::BaseHandle *argp1 ;
90605   Dali::Toolkit::PageTurnPortraitView result;
90606
90607   argp1 = (Dali::BaseHandle *)jarg1;
90608   if (!argp1) {
90609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90610     return 0;
90611   }
90612   arg1 = *argp1;
90613   {
90614     try {
90615       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90616     } catch (std::out_of_range& e) {
90617       {
90618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90619       };
90620     } catch (std::exception& e) {
90621       {
90622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90623       };
90624     } catch (Dali::DaliException e) {
90625       {
90626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90627       };
90628     } catch (...) {
90629       {
90630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90631       };
90632     }
90633   }
90634
90635   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90636   return jresult;
90637 }
90638
90639
90640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90641   int jresult ;
90642   int result;
90643
90644   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90645   jresult = (int)result;
90646   return jresult;
90647 }
90648
90649
90650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90651   int jresult ;
90652   int result;
90653
90654   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90655   jresult = (int)result;
90656   return jresult;
90657 }
90658
90659
90660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90661   int jresult ;
90662   int result;
90663
90664   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90665   jresult = (int)result;
90666   return jresult;
90667 }
90668
90669
90670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90671   void * jresult ;
90672   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90673
90674   {
90675     try {
90676       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90677     } catch (std::out_of_range& e) {
90678       {
90679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (std::exception& e) {
90682       {
90683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (Dali::DaliException e) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90688       };
90689     } catch (...) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90692       };
90693     }
90694   }
90695
90696   jresult = (void *)result;
90697   return jresult;
90698 }
90699
90700
90701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90702   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90703
90704   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90705   {
90706     try {
90707       delete arg1;
90708     } catch (std::out_of_range& e) {
90709       {
90710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90711       };
90712     } catch (std::exception& e) {
90713       {
90714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90715       };
90716     } catch (Dali::DaliException e) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90719       };
90720     } catch (...) {
90721       {
90722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90723       };
90724     }
90725   }
90726
90727 }
90728
90729
90730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90731   void * jresult ;
90732   Dali::Toolkit::ToggleButton *result = 0 ;
90733
90734   {
90735     try {
90736       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90737     } catch (std::out_of_range& e) {
90738       {
90739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90740       };
90741     } catch (std::exception& e) {
90742       {
90743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90744       };
90745     } catch (Dali::DaliException e) {
90746       {
90747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90748       };
90749     } catch (...) {
90750       {
90751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90752       };
90753     }
90754   }
90755
90756   jresult = (void *)result;
90757   return jresult;
90758 }
90759
90760
90761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90762   void * jresult ;
90763   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90764   Dali::Toolkit::ToggleButton *result = 0 ;
90765
90766   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90767   if (!arg1) {
90768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90769     return 0;
90770   }
90771   {
90772     try {
90773       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90774     } catch (std::out_of_range& e) {
90775       {
90776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90777       };
90778     } catch (std::exception& e) {
90779       {
90780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90781       };
90782     } catch (Dali::DaliException e) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90785       };
90786     } catch (...) {
90787       {
90788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90789       };
90790     }
90791   }
90792
90793   jresult = (void *)result;
90794   return jresult;
90795 }
90796
90797
90798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90799   void * jresult ;
90800   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90801   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90802   Dali::Toolkit::ToggleButton *result = 0 ;
90803
90804   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90805   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90806   if (!arg2) {
90807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90808     return 0;
90809   }
90810   {
90811     try {
90812       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90813     } catch (std::out_of_range& e) {
90814       {
90815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (std::exception& e) {
90818       {
90819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90820       };
90821     } catch (Dali::DaliException e) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90824       };
90825     } catch (...) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90828       };
90829     }
90830   }
90831
90832   jresult = (void *)result;
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90838   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90839
90840   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90841   {
90842     try {
90843       delete arg1;
90844     } catch (std::out_of_range& e) {
90845       {
90846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (std::exception& e) {
90849       {
90850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90851       };
90852     } catch (Dali::DaliException e) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90855       };
90856     } catch (...) {
90857       {
90858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90859       };
90860     }
90861   }
90862
90863 }
90864
90865
90866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90867   void * jresult ;
90868   Dali::Toolkit::ToggleButton result;
90869
90870   {
90871     try {
90872       result = Dali::Toolkit::ToggleButton::New();
90873     } catch (std::out_of_range& e) {
90874       {
90875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (std::exception& e) {
90878       {
90879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90880       };
90881     } catch (Dali::DaliException e) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90884       };
90885     } catch (...) {
90886       {
90887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90888       };
90889     }
90890   }
90891
90892   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90893   return jresult;
90894 }
90895
90896
90897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90898   void * jresult ;
90899   Dali::BaseHandle arg1 ;
90900   Dali::BaseHandle *argp1 ;
90901   Dali::Toolkit::ToggleButton result;
90902
90903   argp1 = (Dali::BaseHandle *)jarg1;
90904   if (!argp1) {
90905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90906     return 0;
90907   }
90908   arg1 = *argp1;
90909   {
90910     try {
90911       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90912     } catch (std::out_of_range& e) {
90913       {
90914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (std::exception& e) {
90917       {
90918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90919       };
90920     } catch (Dali::DaliException e) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90923       };
90924     } catch (...) {
90925       {
90926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90927       };
90928     }
90929   }
90930
90931   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90932   return jresult;
90933 }
90934
90935
90936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90937   void * jresult ;
90938   Dali::Toolkit::Visual::Base *result = 0 ;
90939
90940   {
90941     try {
90942       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90943     } catch (std::out_of_range& e) {
90944       {
90945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90946       };
90947     } catch (std::exception& e) {
90948       {
90949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90950       };
90951     } catch (Dali::DaliException e) {
90952       {
90953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90954       };
90955     } catch (...) {
90956       {
90957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90958       };
90959     }
90960   }
90961
90962   jresult = (void *)result;
90963   return jresult;
90964 }
90965
90966
90967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90968   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90969
90970   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90971   {
90972     try {
90973       delete arg1;
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90981       };
90982     } catch (Dali::DaliException e) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90985       };
90986     } catch (...) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90989       };
90990     }
90991   }
90992
90993 }
90994
90995
90996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90997   void * jresult ;
90998   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90999   Dali::Toolkit::Visual::Base *result = 0 ;
91000
91001   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91002   if (!arg1) {
91003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91004     return 0;
91005   }
91006   {
91007     try {
91008       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91009     } catch (std::out_of_range& e) {
91010       {
91011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91012       };
91013     } catch (std::exception& e) {
91014       {
91015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91016       };
91017     } catch (Dali::DaliException e) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91020       };
91021     } catch (...) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91024       };
91025     }
91026   }
91027
91028   jresult = (void *)result;
91029   return jresult;
91030 }
91031
91032
91033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91034   void * jresult ;
91035   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91036   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91037   Dali::Toolkit::Visual::Base *result = 0 ;
91038
91039   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91040   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91041   if (!arg2) {
91042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91043     return 0;
91044   }
91045   {
91046     try {
91047       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91048     } catch (std::out_of_range& e) {
91049       {
91050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91051       };
91052     } catch (std::exception& e) {
91053       {
91054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91055       };
91056     } catch (Dali::DaliException e) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91059       };
91060     } catch (...) {
91061       {
91062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91063       };
91064     }
91065   }
91066
91067   jresult = (void *)result;
91068   return jresult;
91069 }
91070
91071
91072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91073   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91074   std::string *arg2 = 0 ;
91075
91076   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91077   if (!jarg2) {
91078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91079     return ;
91080   }
91081   std::string arg2_str(jarg2);
91082   arg2 = &arg2_str;
91083   {
91084     try {
91085       (arg1)->SetName((std::string const &)*arg2);
91086     } catch (std::out_of_range& e) {
91087       {
91088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91089       };
91090     } catch (std::exception& e) {
91091       {
91092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (Dali::DaliException e) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91101       };
91102     }
91103   }
91104
91105
91106   //argout typemap for const std::string&
91107
91108 }
91109
91110
91111 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91112   char * jresult ;
91113   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91114   std::string *result = 0 ;
91115
91116   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91117   {
91118     try {
91119       result = (std::string *) &(arg1)->GetName();
91120     } catch (std::out_of_range& e) {
91121       {
91122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (std::exception& e) {
91125       {
91126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91127       };
91128     } catch (Dali::DaliException e) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91131       };
91132     } catch (...) {
91133       {
91134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91135       };
91136     }
91137   }
91138
91139   jresult = SWIG_csharp_string_callback(result->c_str());
91140   return jresult;
91141 }
91142
91143
91144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91145   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91146   Dali::Property::Map *arg2 = 0 ;
91147   Dali::Size arg3 ;
91148   Dali::Size *argp3 ;
91149
91150   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91151   arg2 = (Dali::Property::Map *)jarg2;
91152   if (!arg2) {
91153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91154     return ;
91155   }
91156   argp3 = (Dali::Size *)jarg3;
91157   if (!argp3) {
91158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91159     return ;
91160   }
91161   arg3 = *argp3;
91162   {
91163     try {
91164       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91165     } catch (std::out_of_range& e) {
91166       {
91167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91168       };
91169     } catch (std::exception& e) {
91170       {
91171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91172       };
91173     } catch (Dali::DaliException e) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91176       };
91177     } catch (...) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91180       };
91181     }
91182   }
91183
91184 }
91185
91186
91187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91188   float jresult ;
91189   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91190   float arg2 ;
91191   float result;
91192
91193   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91194   arg2 = (float)jarg2;
91195   {
91196     try {
91197       result = (float)(arg1)->GetHeightForWidth(arg2);
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91205       };
91206     } catch (Dali::DaliException e) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91209       };
91210     } catch (...) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91213       };
91214     }
91215   }
91216
91217   jresult = result;
91218   return jresult;
91219 }
91220
91221
91222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91223   float jresult ;
91224   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91225   float arg2 ;
91226   float result;
91227
91228   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91229   arg2 = (float)jarg2;
91230   {
91231     try {
91232       result = (float)(arg1)->GetWidthForHeight(arg2);
91233     } catch (std::out_of_range& e) {
91234       {
91235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (std::exception& e) {
91238       {
91239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91240       };
91241     } catch (Dali::DaliException e) {
91242       {
91243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91244       };
91245     } catch (...) {
91246       {
91247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91248       };
91249     }
91250   }
91251
91252   jresult = result;
91253   return jresult;
91254 }
91255
91256
91257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91258   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91259   Dali::Vector2 *arg2 = 0 ;
91260
91261   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91262   arg2 = (Dali::Vector2 *)jarg2;
91263   if (!arg2) {
91264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91265     return ;
91266   }
91267   {
91268     try {
91269       (arg1)->GetNaturalSize(*arg2);
91270     } catch (std::out_of_range& e) {
91271       {
91272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91273       };
91274     } catch (std::exception& e) {
91275       {
91276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91277       };
91278     } catch (Dali::DaliException e) {
91279       {
91280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91281       };
91282     } catch (...) {
91283       {
91284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91285       };
91286     }
91287   }
91288
91289 }
91290
91291
91292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91293   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91294   float arg2 ;
91295
91296   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91297   arg2 = (int)jarg2;
91298   {
91299     try {
91300       (arg1)->SetDepthIndex(arg2);
91301     } catch (std::out_of_range& e) {
91302       {
91303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91304       };
91305     } catch (std::exception& e) {
91306       {
91307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91308       };
91309     } catch (Dali::DaliException e) {
91310       {
91311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91312       };
91313     } catch (...) {
91314       {
91315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91316       };
91317     }
91318   }
91319
91320 }
91321
91322
91323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91324   int jresult ;
91325   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91326   int result;
91327
91328   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91329   {
91330     try {
91331       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91332     } catch (std::out_of_range& e) {
91333       {
91334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (std::exception& e) {
91337       {
91338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91339       };
91340     } catch (Dali::DaliException e) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91343       };
91344     } catch (...) {
91345       {
91346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91347       };
91348     }
91349   }
91350
91351   jresult = result;
91352   return jresult;
91353 }
91354
91355
91356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91357   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91358   Dali::Property::Map *arg2 = 0 ;
91359
91360   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91361   arg2 = (Dali::Property::Map *)jarg2;
91362   if (!arg2) {
91363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91364     return ;
91365   }
91366   {
91367     try {
91368       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91369     } catch (std::out_of_range& e) {
91370       {
91371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (std::exception& e) {
91374       {
91375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91376       };
91377     } catch (Dali::DaliException e) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91380       };
91381     } catch (...) {
91382       {
91383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91384       };
91385     }
91386   }
91387
91388 }
91389
91390
91391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91392   void * jresult ;
91393   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91394   Dali::Toolkit::Visual::Base *result = 0 ;
91395
91396   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91397   {
91398     try {
91399       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91400     } catch (std::out_of_range& e) {
91401       {
91402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91403       };
91404     } catch (std::exception& e) {
91405       {
91406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91407       };
91408     } catch (Dali::DaliException e) {
91409       {
91410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91411       };
91412     } catch (...) {
91413       {
91414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91415       };
91416     }
91417   }
91418
91419   jresult = (void *)result;
91420   return jresult;
91421 }
91422
91423
91424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91425   void * jresult ;
91426   Dali::Toolkit::VisualFactory result;
91427
91428   {
91429     try {
91430       result = Dali::Toolkit::VisualFactory::Get();
91431     } catch (std::out_of_range& e) {
91432       {
91433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91434       };
91435     } catch (std::exception& e) {
91436       {
91437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91438       };
91439     } catch (Dali::DaliException e) {
91440       {
91441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91442       };
91443     } catch (...) {
91444       {
91445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91446       };
91447     }
91448   }
91449
91450   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91451   return jresult;
91452 }
91453
91454
91455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91456   void * jresult ;
91457   Dali::Toolkit::VisualFactory *result = 0 ;
91458
91459   {
91460     try {
91461       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91462     } catch (std::out_of_range& e) {
91463       {
91464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91465       };
91466     } catch (std::exception& e) {
91467       {
91468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91469       };
91470     } catch (Dali::DaliException e) {
91471       {
91472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91473       };
91474     } catch (...) {
91475       {
91476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91477       };
91478     }
91479   }
91480
91481   jresult = (void *)result;
91482   return jresult;
91483 }
91484
91485
91486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91487   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91488
91489   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91490   {
91491     try {
91492       delete arg1;
91493     } catch (std::out_of_range& e) {
91494       {
91495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91496       };
91497     } catch (std::exception& e) {
91498       {
91499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91500       };
91501     } catch (Dali::DaliException e) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91504       };
91505     } catch (...) {
91506       {
91507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91508       };
91509     }
91510   }
91511
91512 }
91513
91514
91515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91516   void * jresult ;
91517   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91518   Dali::Toolkit::VisualFactory *result = 0 ;
91519
91520   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91521   if (!arg1) {
91522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91523     return 0;
91524   }
91525   {
91526     try {
91527       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91528     } catch (std::out_of_range& e) {
91529       {
91530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91531       };
91532     } catch (std::exception& e) {
91533       {
91534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91535       };
91536     } catch (Dali::DaliException e) {
91537       {
91538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91539       };
91540     } catch (...) {
91541       {
91542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91543       };
91544     }
91545   }
91546
91547   jresult = (void *)result;
91548   return jresult;
91549 }
91550
91551
91552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91553   void * jresult ;
91554   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91555   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91556   Dali::Toolkit::VisualFactory *result = 0 ;
91557
91558   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91559   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91560   if (!arg2) {
91561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91562     return 0;
91563   }
91564   {
91565     try {
91566       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91567     } catch (std::out_of_range& e) {
91568       {
91569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91570       };
91571     } catch (std::exception& e) {
91572       {
91573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91574       };
91575     } catch (Dali::DaliException e) {
91576       {
91577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91578       };
91579     } catch (...) {
91580       {
91581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91582       };
91583     }
91584   }
91585
91586   jresult = (void *)result;
91587   return jresult;
91588 }
91589
91590
91591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91592   void * jresult ;
91593   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91594   Dali::Property::Map *arg2 = 0 ;
91595   Dali::Toolkit::Visual::Base result;
91596
91597   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91598   arg2 = (Dali::Property::Map *)jarg2;
91599   if (!arg2) {
91600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91601     return 0;
91602   }
91603   {
91604     try {
91605       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91606     } catch (std::out_of_range& e) {
91607       {
91608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91609       };
91610     } catch (std::exception& e) {
91611       {
91612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91613       };
91614     } catch (Dali::DaliException e) {
91615       {
91616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91617       };
91618     } catch (...) {
91619       {
91620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91621       };
91622     }
91623   }
91624
91625   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91626   return jresult;
91627 }
91628
91629
91630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91631   void * jresult ;
91632   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91633   Dali::Image *arg2 = 0 ;
91634   Dali::Toolkit::Visual::Base result;
91635
91636   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91637   arg2 = (Dali::Image *)jarg2;
91638   if (!arg2) {
91639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91640     return 0;
91641   }
91642   {
91643     try {
91644       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91645     } catch (std::out_of_range& e) {
91646       {
91647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91648       };
91649     } catch (std::exception& e) {
91650       {
91651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91652       };
91653     } catch (Dali::DaliException e) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91656       };
91657     } catch (...) {
91658       {
91659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91660       };
91661     }
91662   }
91663
91664   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91665   return jresult;
91666 }
91667
91668
91669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91670   void * jresult ;
91671   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91672   std::string *arg2 = 0 ;
91673   Dali::ImageDimensions arg3 ;
91674   Dali::ImageDimensions *argp3 ;
91675   Dali::Toolkit::Visual::Base result;
91676
91677   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91678   if (!jarg2) {
91679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91680     return 0;
91681   }
91682   std::string arg2_str(jarg2);
91683   arg2 = &arg2_str;
91684   argp3 = (Dali::ImageDimensions *)jarg3;
91685   if (!argp3) {
91686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91687     return 0;
91688   }
91689   arg3 = *argp3;
91690   {
91691     try {
91692       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91693     } catch (std::out_of_range& e) {
91694       {
91695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91696       };
91697     } catch (std::exception& e) {
91698       {
91699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91700       };
91701     } catch (Dali::DaliException e) {
91702       {
91703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91704       };
91705     } catch (...) {
91706       {
91707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91708       };
91709     }
91710   }
91711
91712   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91713
91714   //argout typemap for const std::string&
91715
91716   return jresult;
91717 }
91718
91719
91720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91721   void * jresult ;
91722   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91723
91724   {
91725     try {
91726       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91727     } catch (std::out_of_range& e) {
91728       {
91729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91730       };
91731     } catch (std::exception& e) {
91732       {
91733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91734       };
91735     } catch (Dali::DaliException e) {
91736       {
91737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91738       };
91739     } catch (...) {
91740       {
91741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91742       };
91743     }
91744   }
91745
91746   jresult = (void *)result;
91747   return jresult;
91748 }
91749
91750
91751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91752   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91753
91754   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91755   {
91756     try {
91757       delete arg1;
91758     } catch (std::out_of_range& e) {
91759       {
91760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91761       };
91762     } catch (std::exception& e) {
91763       {
91764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91765       };
91766     } catch (Dali::DaliException e) {
91767       {
91768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91769       };
91770     } catch (...) {
91771       {
91772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91773       };
91774     }
91775   }
91776
91777 }
91778
91779
91780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91781   void * jresult ;
91782   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91783   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91784
91785   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91786   if (!arg1) {
91787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91788     return 0;
91789   }
91790   {
91791     try {
91792       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91793     } catch (std::out_of_range& e) {
91794       {
91795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91796       };
91797     } catch (std::exception& e) {
91798       {
91799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91800       };
91801     } catch (Dali::DaliException e) {
91802       {
91803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91804       };
91805     } catch (...) {
91806       {
91807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91808       };
91809     }
91810   }
91811
91812   jresult = (void *)result;
91813   return jresult;
91814 }
91815
91816
91817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91818   void * jresult ;
91819   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91820   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91821   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91822
91823   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91824   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91825   if (!arg2) {
91826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91827     return 0;
91828   }
91829   {
91830     try {
91831       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91839       };
91840     } catch (Dali::DaliException e) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91843       };
91844     } catch (...) {
91845       {
91846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91847       };
91848     }
91849   }
91850
91851   jresult = (void *)result;
91852   return jresult;
91853 }
91854
91855
91856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91857   void * jresult ;
91858   Dali::Toolkit::AsyncImageLoader result;
91859
91860   {
91861     try {
91862       result = Dali::Toolkit::AsyncImageLoader::New();
91863     } catch (std::out_of_range& e) {
91864       {
91865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91866       };
91867     } catch (std::exception& e) {
91868       {
91869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91870       };
91871     } catch (Dali::DaliException e) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91874       };
91875     } catch (...) {
91876       {
91877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91878       };
91879     }
91880   }
91881
91882   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91883   return jresult;
91884 }
91885
91886
91887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91888   void * jresult ;
91889   Dali::BaseHandle arg1 ;
91890   Dali::BaseHandle *argp1 ;
91891   Dali::Toolkit::AsyncImageLoader result;
91892
91893   argp1 = (Dali::BaseHandle *)jarg1;
91894   if (!argp1) {
91895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91896     return 0;
91897   }
91898   arg1 = *argp1;
91899   {
91900     try {
91901       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91902     } catch (std::out_of_range& e) {
91903       {
91904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91905       };
91906     } catch (std::exception& e) {
91907       {
91908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91909       };
91910     } catch (Dali::DaliException e) {
91911       {
91912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91913       };
91914     } catch (...) {
91915       {
91916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91917       };
91918     }
91919   }
91920
91921   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91922   return jresult;
91923 }
91924
91925
91926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91927   unsigned int jresult ;
91928   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91929   std::string *arg2 = 0 ;
91930   uint32_t result;
91931
91932   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91933   if (!jarg2) {
91934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91935     return 0;
91936   }
91937   std::string arg2_str(jarg2);
91938   arg2 = &arg2_str;
91939   {
91940     try {
91941       result = (arg1)->Load((std::string const &)*arg2);
91942     } catch (std::out_of_range& e) {
91943       {
91944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91945       };
91946     } catch (std::exception& e) {
91947       {
91948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91949       };
91950     } catch (Dali::DaliException e) {
91951       {
91952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91953       };
91954     } catch (...) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91957       };
91958     }
91959   }
91960
91961   jresult = result;
91962
91963   //argout typemap for const std::string&
91964
91965   return jresult;
91966 }
91967
91968
91969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91970   unsigned int jresult ;
91971   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91972   std::string *arg2 = 0 ;
91973   Dali::ImageDimensions arg3 ;
91974   Dali::ImageDimensions *argp3 ;
91975   uint32_t result;
91976
91977   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91978   if (!jarg2) {
91979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91980     return 0;
91981   }
91982   std::string arg2_str(jarg2);
91983   arg2 = &arg2_str;
91984   argp3 = (Dali::ImageDimensions *)jarg3;
91985   if (!argp3) {
91986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91987     return 0;
91988   }
91989   arg3 = *argp3;
91990   {
91991     try {
91992       result = (arg1)->Load((std::string const &)*arg2,arg3);
91993     } catch (std::out_of_range& e) {
91994       {
91995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91996       };
91997     } catch (std::exception& e) {
91998       {
91999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92000       };
92001     } catch (Dali::DaliException e) {
92002       {
92003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92004       };
92005     } catch (...) {
92006       {
92007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92008       };
92009     }
92010   }
92011
92012   jresult = result;
92013
92014   //argout typemap for const std::string&
92015
92016   return jresult;
92017 }
92018
92019
92020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92021   unsigned int jresult ;
92022   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92023   std::string *arg2 = 0 ;
92024   Dali::ImageDimensions arg3 ;
92025   Dali::FittingMode::Type arg4 ;
92026   Dali::SamplingMode::Type arg5 ;
92027   bool arg6 ;
92028   Dali::ImageDimensions *argp3 ;
92029   uint32_t result;
92030
92031   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92032   if (!jarg2) {
92033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92034     return 0;
92035   }
92036   std::string arg2_str(jarg2);
92037   arg2 = &arg2_str;
92038   argp3 = (Dali::ImageDimensions *)jarg3;
92039   if (!argp3) {
92040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92041     return 0;
92042   }
92043   arg3 = *argp3;
92044   arg4 = (Dali::FittingMode::Type)jarg4;
92045   arg5 = (Dali::SamplingMode::Type)jarg5;
92046   arg6 = jarg6 ? true : false;
92047   {
92048     try {
92049       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92050     } catch (std::out_of_range& e) {
92051       {
92052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92053       };
92054     } catch (std::exception& e) {
92055       {
92056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92057       };
92058     } catch (Dali::DaliException e) {
92059       {
92060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92061       };
92062     } catch (...) {
92063       {
92064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92065       };
92066     }
92067   }
92068
92069   jresult = result;
92070
92071   //argout typemap for const std::string&
92072
92073   return jresult;
92074 }
92075
92076
92077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92078   unsigned int jresult ;
92079   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92080   uint32_t arg2 ;
92081   bool result;
92082
92083   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92084   arg2 = (uint32_t)jarg2;
92085   {
92086     try {
92087       result = (bool)(arg1)->Cancel(arg2);
92088     } catch (std::out_of_range& e) {
92089       {
92090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (std::exception& e) {
92093       {
92094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92095       };
92096     } catch (Dali::DaliException e) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92099       };
92100     } catch (...) {
92101       {
92102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92103       };
92104     }
92105   }
92106
92107   jresult = result;
92108   return jresult;
92109 }
92110
92111
92112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92113   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92114
92115   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92116   {
92117     try {
92118       (arg1)->CancelAll();
92119     } catch (std::out_of_range& e) {
92120       {
92121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92122       };
92123     } catch (std::exception& e) {
92124       {
92125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92126       };
92127     } catch (Dali::DaliException e) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92130       };
92131     } catch (...) {
92132       {
92133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92134       };
92135     }
92136   }
92137
92138 }
92139
92140
92141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92142   void * jresult ;
92143   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92144   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92145
92146   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92147   {
92148     try {
92149       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92150     } catch (std::out_of_range& e) {
92151       {
92152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92153       };
92154     } catch (std::exception& e) {
92155       {
92156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92157       };
92158     } catch (Dali::DaliException e) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92161       };
92162     } catch (...) {
92163       {
92164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92165       };
92166     }
92167   }
92168
92169   jresult = (void *)result;
92170   return jresult;
92171 }
92172
92173
92174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92175   void * jresult ;
92176   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92177   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92178
92179   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92180   {
92181     try {
92182       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92183     } catch (std::out_of_range& e) {
92184       {
92185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (std::exception& e) {
92188       {
92189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (Dali::DaliException e) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92194       };
92195     } catch (...) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92198       };
92199     }
92200   }
92201
92202   jresult = (void *)result;
92203   return jresult;
92204 }
92205
92206
92207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92208   void * jresult ;
92209   std::string *arg1 = 0 ;
92210   Dali::PixelData result;
92211
92212   if (!jarg1) {
92213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92214     return 0;
92215   }
92216   std::string arg1_str(jarg1);
92217   arg1 = &arg1_str;
92218   {
92219     try {
92220       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92221     } catch (std::out_of_range& e) {
92222       {
92223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92224       };
92225     } catch (std::exception& e) {
92226       {
92227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92228       };
92229     } catch (Dali::DaliException e) {
92230       {
92231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92232       };
92233     } catch (...) {
92234       {
92235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92236       };
92237     }
92238   }
92239
92240   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92241
92242   //argout typemap for const std::string&
92243
92244   return jresult;
92245 }
92246
92247
92248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92249   void * jresult ;
92250   std::string *arg1 = 0 ;
92251   Dali::ImageDimensions arg2 ;
92252   Dali::ImageDimensions *argp2 ;
92253   Dali::PixelData result;
92254
92255   if (!jarg1) {
92256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92257     return 0;
92258   }
92259   std::string arg1_str(jarg1);
92260   arg1 = &arg1_str;
92261   argp2 = (Dali::ImageDimensions *)jarg2;
92262   if (!argp2) {
92263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92264     return 0;
92265   }
92266   arg2 = *argp2;
92267   {
92268     try {
92269       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92270     } catch (std::out_of_range& e) {
92271       {
92272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (std::exception& e) {
92275       {
92276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92277       };
92278     } catch (Dali::DaliException e) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92281       };
92282     } catch (...) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92285       };
92286     }
92287   }
92288
92289   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92290
92291   //argout typemap for const std::string&
92292
92293   return jresult;
92294 }
92295
92296
92297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92298   void * jresult ;
92299   std::string *arg1 = 0 ;
92300   Dali::ImageDimensions arg2 ;
92301   Dali::FittingMode::Type arg3 ;
92302   Dali::SamplingMode::Type arg4 ;
92303   bool arg5 ;
92304   Dali::ImageDimensions *argp2 ;
92305   Dali::PixelData result;
92306
92307   if (!jarg1) {
92308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92309     return 0;
92310   }
92311   std::string arg1_str(jarg1);
92312   arg1 = &arg1_str;
92313   argp2 = (Dali::ImageDimensions *)jarg2;
92314   if (!argp2) {
92315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92316     return 0;
92317   }
92318   arg2 = *argp2;
92319   arg3 = (Dali::FittingMode::Type)jarg3;
92320   arg4 = (Dali::SamplingMode::Type)jarg4;
92321   arg5 = jarg5 ? true : false;
92322   {
92323     try {
92324       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92340       };
92341     }
92342   }
92343
92344   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92345
92346   //argout typemap for const std::string&
92347
92348   return jresult;
92349 }
92350
92351
92352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92353   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92354
92355   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92356   {
92357     try {
92358       delete arg1;
92359     } catch (std::out_of_range& e) {
92360       {
92361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92362       };
92363     } catch (std::exception& e) {
92364       {
92365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92366       };
92367     } catch (Dali::DaliException e) {
92368       {
92369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92370       };
92371     } catch (...) {
92372       {
92373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92374       };
92375     }
92376   }
92377
92378 }
92379
92380
92381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92382   void * jresult ;
92383   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92384   Dali::Actor arg2 ;
92385   Dali::Actor arg3 ;
92386   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92387   Dali::Actor *argp2 ;
92388   Dali::Actor *argp3 ;
92389   Dali::Actor result;
92390
92391   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92392   argp2 = (Dali::Actor *)jarg2;
92393   if (!argp2) {
92394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92395     return 0;
92396   }
92397   arg2 = *argp2;
92398   argp3 = (Dali::Actor *)jarg3;
92399   if (!argp3) {
92400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92401     return 0;
92402   }
92403   arg3 = *argp3;
92404   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92405   {
92406     try {
92407       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92408     } catch (std::out_of_range& e) {
92409       {
92410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92411       };
92412     } catch (std::exception& e) {
92413       {
92414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92415       };
92416     } catch (Dali::DaliException e) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92419       };
92420     } catch (...) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92423       };
92424     }
92425   }
92426
92427   jresult = new Dali::Actor((const Dali::Actor &)result);
92428   return jresult;
92429 }
92430
92431
92432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92433   void * jresult ;
92434   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92435
92436   {
92437     try {
92438       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92439     } catch (std::out_of_range& e) {
92440       {
92441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92442       };
92443     } catch (std::exception& e) {
92444       {
92445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92446       };
92447     } catch (Dali::DaliException e) {
92448       {
92449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92450       };
92451     } catch (...) {
92452       {
92453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92454       };
92455     }
92456   }
92457
92458   jresult = (void *)result;
92459   return jresult;
92460 }
92461
92462
92463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92464   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92465   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92466   if (director) {
92467     director->swig_connect_director(callback0);
92468   }
92469 }
92470
92471
92472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92473   KeyboardFocusManager arg1 ;
92474   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92475   KeyboardFocusManager *argp1 ;
92476
92477   argp1 = (KeyboardFocusManager *)jarg1;
92478   if (!argp1) {
92479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92480     return ;
92481   }
92482   arg1 = *argp1;
92483   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92484   if (!arg2) {
92485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92486     return ;
92487   }
92488   {
92489     try {
92490       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92491     } catch (std::out_of_range& e) {
92492       {
92493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92494       };
92495     } catch (std::exception& e) {
92496       {
92497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92498       };
92499     } catch (Dali::DaliException e) {
92500       {
92501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92502       };
92503     } catch (...) {
92504       {
92505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92506       };
92507     }
92508   }
92509
92510 }
92511
92512
92513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92514   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92515
92516   arg1 = (std::vector< unsigned int > *)jarg1;
92517   {
92518     try {
92519       (arg1)->clear();
92520     } catch (std::out_of_range& e) {
92521       {
92522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92523       };
92524     } catch (std::exception& e) {
92525       {
92526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92527       };
92528     } catch (Dali::DaliException e) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92531       };
92532     } catch (...) {
92533       {
92534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92535       };
92536     }
92537   }
92538
92539 }
92540
92541
92542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92543   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92544   unsigned int *arg2 = 0 ;
92545   unsigned int temp2 ;
92546
92547   arg1 = (std::vector< unsigned int > *)jarg1;
92548   temp2 = (unsigned int)jarg2;
92549   arg2 = &temp2;
92550   {
92551     try {
92552       (arg1)->push_back((unsigned int const &)*arg2);
92553     } catch (std::out_of_range& e) {
92554       {
92555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (std::exception& e) {
92558       {
92559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92560       };
92561     } catch (Dali::DaliException e) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92564       };
92565     } catch (...) {
92566       {
92567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92568       };
92569     }
92570   }
92571
92572 }
92573
92574
92575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92576   unsigned long jresult ;
92577   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92578   std::vector< unsigned int >::size_type result;
92579
92580   arg1 = (std::vector< unsigned int > *)jarg1;
92581   {
92582     try {
92583       result = ((std::vector< unsigned int > const *)arg1)->size();
92584     } catch (std::out_of_range& e) {
92585       {
92586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (std::exception& e) {
92589       {
92590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92591       };
92592     } catch (Dali::DaliException e) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92595       };
92596     } catch (...) {
92597       {
92598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92599       };
92600     }
92601   }
92602
92603   jresult = (unsigned long)result;
92604   return jresult;
92605 }
92606
92607
92608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92609   unsigned long jresult ;
92610   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92611   std::vector< unsigned int >::size_type result;
92612
92613   arg1 = (std::vector< unsigned int > *)jarg1;
92614   {
92615     try {
92616       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92617     } catch (std::out_of_range& e) {
92618       {
92619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (std::exception& e) {
92622       {
92623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92624       };
92625     } catch (Dali::DaliException e) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92628       };
92629     } catch (...) {
92630       {
92631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92632       };
92633     }
92634   }
92635
92636   jresult = (unsigned long)result;
92637   return jresult;
92638 }
92639
92640
92641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92642   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92643   std::vector< unsigned int >::size_type arg2 ;
92644
92645   arg1 = (std::vector< unsigned int > *)jarg1;
92646   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92647   {
92648     try {
92649       (arg1)->reserve(arg2);
92650     } catch (std::out_of_range& e) {
92651       {
92652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92653       };
92654     } catch (std::exception& e) {
92655       {
92656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92657       };
92658     } catch (Dali::DaliException e) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92661       };
92662     } catch (...) {
92663       {
92664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92665       };
92666     }
92667   }
92668
92669 }
92670
92671
92672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92673   void * jresult ;
92674   std::vector< unsigned int > *result = 0 ;
92675
92676   {
92677     try {
92678       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92679     } catch (std::out_of_range& e) {
92680       {
92681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92682       };
92683     } catch (std::exception& e) {
92684       {
92685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92686       };
92687     } catch (Dali::DaliException e) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92690       };
92691     } catch (...) {
92692       {
92693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92694       };
92695     }
92696   }
92697
92698   jresult = (void *)result;
92699   return jresult;
92700 }
92701
92702
92703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92704   void * jresult ;
92705   std::vector< unsigned int > *arg1 = 0 ;
92706   std::vector< unsigned int > *result = 0 ;
92707
92708   arg1 = (std::vector< unsigned int > *)jarg1;
92709   if (!arg1) {
92710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92711     return 0;
92712   }
92713   {
92714     try {
92715       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92716     } catch (std::out_of_range& e) {
92717       {
92718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (std::exception& e) {
92721       {
92722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92723       };
92724     } catch (Dali::DaliException e) {
92725       {
92726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92727       };
92728     } catch (...) {
92729       {
92730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92731       };
92732     }
92733   }
92734
92735   jresult = (void *)result;
92736   return jresult;
92737 }
92738
92739
92740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92741   void * jresult ;
92742   int arg1 ;
92743   std::vector< unsigned int > *result = 0 ;
92744
92745   arg1 = (int)jarg1;
92746   {
92747     try {
92748       try {
92749         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92750       }
92751       catch(std::out_of_range &_e) {
92752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92753         return 0;
92754       }
92755
92756     } catch (std::out_of_range& e) {
92757       {
92758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92759       };
92760     } catch (std::exception& e) {
92761       {
92762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92763       };
92764     } catch (Dali::DaliException e) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92767       };
92768     } catch (...) {
92769       {
92770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92771       };
92772     }
92773   }
92774
92775   jresult = (void *)result;
92776   return jresult;
92777 }
92778
92779
92780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92781   unsigned int jresult ;
92782   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92783   int arg2 ;
92784   unsigned int result;
92785
92786   arg1 = (std::vector< unsigned int > *)jarg1;
92787   arg2 = (int)jarg2;
92788   {
92789     try {
92790       try {
92791         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92792       }
92793       catch(std::out_of_range &_e) {
92794         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92795         return 0;
92796       }
92797
92798     } catch (std::out_of_range& e) {
92799       {
92800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92801       };
92802     } catch (std::exception& e) {
92803       {
92804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92805       };
92806     } catch (Dali::DaliException e) {
92807       {
92808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92809       };
92810     } catch (...) {
92811       {
92812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92813       };
92814     }
92815   }
92816
92817   jresult = result;
92818   return jresult;
92819 }
92820
92821
92822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92823   unsigned int jresult ;
92824   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92825   int arg2 ;
92826   unsigned int *result = 0 ;
92827
92828   arg1 = (std::vector< unsigned int > *)jarg1;
92829   arg2 = (int)jarg2;
92830   {
92831     try {
92832       try {
92833         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92834       }
92835       catch(std::out_of_range &_e) {
92836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92837         return 0;
92838       }
92839
92840     } catch (std::out_of_range& e) {
92841       {
92842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (std::exception& e) {
92845       {
92846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92847       };
92848     } catch (Dali::DaliException e) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92851       };
92852     } catch (...) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92855       };
92856     }
92857   }
92858
92859   jresult = *result;
92860   return jresult;
92861 }
92862
92863
92864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92865   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92866   int arg2 ;
92867   unsigned int *arg3 = 0 ;
92868   unsigned int temp3 ;
92869
92870   arg1 = (std::vector< unsigned int > *)jarg1;
92871   arg2 = (int)jarg2;
92872   temp3 = (unsigned int)jarg3;
92873   arg3 = &temp3;
92874   {
92875     try {
92876       try {
92877         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92878       }
92879       catch(std::out_of_range &_e) {
92880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92881         return ;
92882       }
92883
92884     } catch (std::out_of_range& e) {
92885       {
92886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92887       };
92888     } catch (std::exception& e) {
92889       {
92890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92891       };
92892     } catch (Dali::DaliException e) {
92893       {
92894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92895       };
92896     } catch (...) {
92897       {
92898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92899       };
92900     }
92901   }
92902
92903 }
92904
92905
92906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92907   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92908   std::vector< unsigned int > *arg2 = 0 ;
92909
92910   arg1 = (std::vector< unsigned int > *)jarg1;
92911   arg2 = (std::vector< unsigned int > *)jarg2;
92912   if (!arg2) {
92913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92914     return ;
92915   }
92916   {
92917     try {
92918       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92919     } catch (std::out_of_range& e) {
92920       {
92921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92922       };
92923     } catch (std::exception& e) {
92924       {
92925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92926       };
92927     } catch (Dali::DaliException e) {
92928       {
92929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92930       };
92931     } catch (...) {
92932       {
92933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92934       };
92935     }
92936   }
92937
92938 }
92939
92940
92941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92942   void * jresult ;
92943   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92944   int arg2 ;
92945   int arg3 ;
92946   std::vector< unsigned int > *result = 0 ;
92947
92948   arg1 = (std::vector< unsigned int > *)jarg1;
92949   arg2 = (int)jarg2;
92950   arg3 = (int)jarg3;
92951   {
92952     try {
92953       try {
92954         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92955       }
92956       catch(std::out_of_range &_e) {
92957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92958         return 0;
92959       }
92960       catch(std::invalid_argument &_e) {
92961         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92962         return 0;
92963       }
92964
92965     } catch (std::out_of_range& e) {
92966       {
92967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92968       };
92969     } catch (std::exception& e) {
92970       {
92971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92972       };
92973     } catch (Dali::DaliException e) {
92974       {
92975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92976       };
92977     } catch (...) {
92978       {
92979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92980       };
92981     }
92982   }
92983
92984   jresult = (void *)result;
92985   return jresult;
92986 }
92987
92988
92989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92990   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92991   int arg2 ;
92992   unsigned int *arg3 = 0 ;
92993   unsigned int temp3 ;
92994
92995   arg1 = (std::vector< unsigned int > *)jarg1;
92996   arg2 = (int)jarg2;
92997   temp3 = (unsigned int)jarg3;
92998   arg3 = &temp3;
92999   {
93000     try {
93001       try {
93002         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93003       }
93004       catch(std::out_of_range &_e) {
93005         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93006         return ;
93007       }
93008
93009     } catch (std::out_of_range& e) {
93010       {
93011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (std::exception& e) {
93014       {
93015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93016       };
93017     } catch (Dali::DaliException e) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93020       };
93021     } catch (...) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93024       };
93025     }
93026   }
93027
93028 }
93029
93030
93031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93032   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93033   int arg2 ;
93034   std::vector< unsigned int > *arg3 = 0 ;
93035
93036   arg1 = (std::vector< unsigned int > *)jarg1;
93037   arg2 = (int)jarg2;
93038   arg3 = (std::vector< unsigned int > *)jarg3;
93039   if (!arg3) {
93040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93041     return ;
93042   }
93043   {
93044     try {
93045       try {
93046         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93047       }
93048       catch(std::out_of_range &_e) {
93049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93050         return ;
93051       }
93052
93053     } catch (std::out_of_range& e) {
93054       {
93055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93056       };
93057     } catch (std::exception& e) {
93058       {
93059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93060       };
93061     } catch (Dali::DaliException e) {
93062       {
93063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93064       };
93065     } catch (...) {
93066       {
93067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93068       };
93069     }
93070   }
93071
93072 }
93073
93074
93075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93076   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93077   int arg2 ;
93078
93079   arg1 = (std::vector< unsigned int > *)jarg1;
93080   arg2 = (int)jarg2;
93081   {
93082     try {
93083       try {
93084         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93085       }
93086       catch(std::out_of_range &_e) {
93087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93088         return ;
93089       }
93090
93091     } catch (std::out_of_range& e) {
93092       {
93093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93094       };
93095     } catch (std::exception& e) {
93096       {
93097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93098       };
93099     } catch (Dali::DaliException e) {
93100       {
93101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93102       };
93103     } catch (...) {
93104       {
93105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93106       };
93107     }
93108   }
93109
93110 }
93111
93112
93113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93114   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93115   int arg2 ;
93116   int arg3 ;
93117
93118   arg1 = (std::vector< unsigned int > *)jarg1;
93119   arg2 = (int)jarg2;
93120   arg3 = (int)jarg3;
93121   {
93122     try {
93123       try {
93124         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93125       }
93126       catch(std::out_of_range &_e) {
93127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93128         return ;
93129       }
93130       catch(std::invalid_argument &_e) {
93131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93132         return ;
93133       }
93134
93135     } catch (std::out_of_range& e) {
93136       {
93137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93138       };
93139     } catch (std::exception& e) {
93140       {
93141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93142       };
93143     } catch (Dali::DaliException e) {
93144       {
93145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93146       };
93147     } catch (...) {
93148       {
93149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93150       };
93151     }
93152   }
93153
93154 }
93155
93156
93157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93158   void * jresult ;
93159   unsigned int *arg1 = 0 ;
93160   int arg2 ;
93161   unsigned int temp1 ;
93162   std::vector< unsigned int > *result = 0 ;
93163
93164   temp1 = (unsigned int)jarg1;
93165   arg1 = &temp1;
93166   arg2 = (int)jarg2;
93167   {
93168     try {
93169       try {
93170         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93171       }
93172       catch(std::out_of_range &_e) {
93173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93174         return 0;
93175       }
93176
93177     } catch (std::out_of_range& e) {
93178       {
93179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93180       };
93181     } catch (std::exception& e) {
93182       {
93183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93184       };
93185     } catch (Dali::DaliException e) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93188       };
93189     } catch (...) {
93190       {
93191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93192       };
93193     }
93194   }
93195
93196   jresult = (void *)result;
93197   return jresult;
93198 }
93199
93200
93201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93202   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93203
93204   arg1 = (std::vector< unsigned int > *)jarg1;
93205   {
93206     try {
93207       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93208     } catch (std::out_of_range& e) {
93209       {
93210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93211       };
93212     } catch (std::exception& e) {
93213       {
93214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93215       };
93216     } catch (Dali::DaliException e) {
93217       {
93218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93219       };
93220     } catch (...) {
93221       {
93222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93223       };
93224     }
93225   }
93226
93227 }
93228
93229
93230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93231   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93232   int arg2 ;
93233   int arg3 ;
93234
93235   arg1 = (std::vector< unsigned int > *)jarg1;
93236   arg2 = (int)jarg2;
93237   arg3 = (int)jarg3;
93238   {
93239     try {
93240       try {
93241         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93242       }
93243       catch(std::out_of_range &_e) {
93244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93245         return ;
93246       }
93247       catch(std::invalid_argument &_e) {
93248         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93249         return ;
93250       }
93251
93252     } catch (std::out_of_range& e) {
93253       {
93254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93255       };
93256     } catch (std::exception& e) {
93257       {
93258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93259       };
93260     } catch (Dali::DaliException e) {
93261       {
93262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93263       };
93264     } catch (...) {
93265       {
93266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93267       };
93268     }
93269   }
93270
93271 }
93272
93273
93274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93275   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93276   int arg2 ;
93277   std::vector< unsigned int > *arg3 = 0 ;
93278
93279   arg1 = (std::vector< unsigned int > *)jarg1;
93280   arg2 = (int)jarg2;
93281   arg3 = (std::vector< unsigned int > *)jarg3;
93282   if (!arg3) {
93283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93284     return ;
93285   }
93286   {
93287     try {
93288       try {
93289         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93290       }
93291       catch(std::out_of_range &_e) {
93292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93293         return ;
93294       }
93295
93296     } catch (std::out_of_range& e) {
93297       {
93298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93299       };
93300     } catch (std::exception& e) {
93301       {
93302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93303       };
93304     } catch (Dali::DaliException e) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93307       };
93308     } catch (...) {
93309       {
93310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93311       };
93312     }
93313   }
93314
93315 }
93316
93317
93318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93319   unsigned int jresult ;
93320   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93321   unsigned int *arg2 = 0 ;
93322   unsigned int temp2 ;
93323   bool result;
93324
93325   arg1 = (std::vector< unsigned int > *)jarg1;
93326   temp2 = (unsigned int)jarg2;
93327   arg2 = &temp2;
93328   {
93329     try {
93330       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93331     } catch (std::out_of_range& e) {
93332       {
93333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93334       };
93335     } catch (std::exception& e) {
93336       {
93337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93338       };
93339     } catch (Dali::DaliException e) {
93340       {
93341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93342       };
93343     } catch (...) {
93344       {
93345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93346       };
93347     }
93348   }
93349
93350   jresult = result;
93351   return jresult;
93352 }
93353
93354
93355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93356   int jresult ;
93357   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93358   unsigned int *arg2 = 0 ;
93359   unsigned int temp2 ;
93360   int result;
93361
93362   arg1 = (std::vector< unsigned int > *)jarg1;
93363   temp2 = (unsigned int)jarg2;
93364   arg2 = &temp2;
93365   {
93366     try {
93367       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93368     } catch (std::out_of_range& e) {
93369       {
93370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93371       };
93372     } catch (std::exception& e) {
93373       {
93374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (Dali::DaliException e) {
93377       {
93378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93379       };
93380     } catch (...) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93383       };
93384     }
93385   }
93386
93387   jresult = result;
93388   return jresult;
93389 }
93390
93391
93392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93393   int jresult ;
93394   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93395   unsigned int *arg2 = 0 ;
93396   unsigned int temp2 ;
93397   int result;
93398
93399   arg1 = (std::vector< unsigned int > *)jarg1;
93400   temp2 = (unsigned int)jarg2;
93401   arg2 = &temp2;
93402   {
93403     try {
93404       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93405     } catch (std::out_of_range& e) {
93406       {
93407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (std::exception& e) {
93410       {
93411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93412       };
93413     } catch (Dali::DaliException e) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93416       };
93417     } catch (...) {
93418       {
93419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93420       };
93421     }
93422   }
93423
93424   jresult = result;
93425   return jresult;
93426 }
93427
93428
93429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93430   unsigned int jresult ;
93431   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93432   unsigned int *arg2 = 0 ;
93433   unsigned int temp2 ;
93434   bool result;
93435
93436   arg1 = (std::vector< unsigned int > *)jarg1;
93437   temp2 = (unsigned int)jarg2;
93438   arg2 = &temp2;
93439   {
93440     try {
93441       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93442     } catch (std::out_of_range& e) {
93443       {
93444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (std::exception& e) {
93447       {
93448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93449       };
93450     } catch (Dali::DaliException e) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93453       };
93454     } catch (...) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93457       };
93458     }
93459   }
93460
93461   jresult = result;
93462   return jresult;
93463 }
93464
93465
93466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93467   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93468
93469   arg1 = (std::vector< unsigned int > *)jarg1;
93470   {
93471     try {
93472       delete arg1;
93473     } catch (std::out_of_range& e) {
93474       {
93475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93476       };
93477     } catch (std::exception& e) {
93478       {
93479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93480       };
93481     } catch (Dali::DaliException e) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93484       };
93485     } catch (...) {
93486       {
93487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93488       };
93489     }
93490   }
93491
93492 }
93493
93494
93495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93496   void * jresult ;
93497   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93498
93499   {
93500     try {
93501       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93502     } catch (std::out_of_range& e) {
93503       {
93504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93505       };
93506     } catch (std::exception& e) {
93507       {
93508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93509       };
93510     } catch (Dali::DaliException e) {
93511       {
93512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93513       };
93514     } catch (...) {
93515       {
93516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93517       };
93518     }
93519   }
93520
93521   jresult = (void *)result;
93522   return jresult;
93523 }
93524
93525
93526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93527   void * jresult ;
93528   unsigned int arg1 ;
93529   Dali::Actor arg2 ;
93530   Dali::Actor *argp2 ;
93531   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93532
93533   arg1 = (unsigned int)jarg1;
93534   argp2 = (Dali::Actor *)jarg2;
93535   if (!argp2) {
93536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93537     return 0;
93538   }
93539   arg2 = *argp2;
93540   {
93541     try {
93542       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93543     } catch (std::out_of_range& e) {
93544       {
93545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93546       };
93547     } catch (std::exception& e) {
93548       {
93549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93550       };
93551     } catch (Dali::DaliException e) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93554       };
93555     } catch (...) {
93556       {
93557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93558       };
93559     }
93560   }
93561
93562   jresult = (void *)result;
93563   return jresult;
93564 }
93565
93566
93567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93568   void * jresult ;
93569   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93570   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93571
93572   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93573   if (!arg1) {
93574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93575     return 0;
93576   }
93577   {
93578     try {
93579       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93580     } catch (std::out_of_range& e) {
93581       {
93582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (std::exception& e) {
93585       {
93586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93587       };
93588     } catch (Dali::DaliException e) {
93589       {
93590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93591       };
93592     } catch (...) {
93593       {
93594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93595       };
93596     }
93597   }
93598
93599   jresult = (void *)result;
93600   return jresult;
93601 }
93602
93603
93604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93605   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93606   unsigned int arg2 ;
93607
93608   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93609   arg2 = (unsigned int)jarg2;
93610   if (arg1) (arg1)->first = arg2;
93611 }
93612
93613
93614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93615   unsigned int jresult ;
93616   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93617   unsigned int result;
93618
93619   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93620   result = (unsigned int) ((arg1)->first);
93621   jresult = result;
93622   return jresult;
93623 }
93624
93625
93626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93627   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93628   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93629
93630   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93631   arg2 = (Dali::Actor *)jarg2;
93632   if (arg1) (arg1)->second = *arg2;
93633 }
93634
93635
93636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93637   void * jresult ;
93638   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93639   Dali::Actor *result = 0 ;
93640
93641   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93642   result = (Dali::Actor *)& ((arg1)->second);
93643   jresult = (void *)result;
93644   return jresult;
93645 }
93646
93647
93648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93649   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93650
93651   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93652   {
93653     try {
93654       delete arg1;
93655     } catch (std::out_of_range& e) {
93656       {
93657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93658       };
93659     } catch (std::exception& e) {
93660       {
93661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93662       };
93663     } catch (Dali::DaliException e) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93666       };
93667     } catch (...) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93670       };
93671     }
93672   }
93673
93674 }
93675
93676
93677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93678   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93679
93680   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93681   {
93682     try {
93683       (arg1)->clear();
93684     } catch (std::out_of_range& e) {
93685       {
93686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93687       };
93688     } catch (std::exception& e) {
93689       {
93690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93691       };
93692     } catch (Dali::DaliException e) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93695       };
93696     } catch (...) {
93697       {
93698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93699       };
93700     }
93701   }
93702
93703 }
93704
93705
93706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93707   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93708   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93709
93710   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93711   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93712   if (!arg2) {
93713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93714     return ;
93715   }
93716   {
93717     try {
93718       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93719     } catch (std::out_of_range& e) {
93720       {
93721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93722       };
93723     } catch (std::exception& e) {
93724       {
93725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93726       };
93727     } catch (Dali::DaliException e) {
93728       {
93729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93730       };
93731     } catch (...) {
93732       {
93733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93734       };
93735     }
93736   }
93737
93738 }
93739
93740
93741 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93742   unsigned long jresult ;
93743   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93744   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93745
93746   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93747   {
93748     try {
93749       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93750     } catch (std::out_of_range& e) {
93751       {
93752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93753       };
93754     } catch (std::exception& e) {
93755       {
93756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93757       };
93758     } catch (Dali::DaliException e) {
93759       {
93760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93761       };
93762     } catch (...) {
93763       {
93764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93765       };
93766     }
93767   }
93768
93769   jresult = (unsigned long)result;
93770   return jresult;
93771 }
93772
93773
93774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93775   unsigned long jresult ;
93776   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93777   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93778
93779   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93780   {
93781     try {
93782       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93783     } catch (std::out_of_range& e) {
93784       {
93785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (std::exception& e) {
93788       {
93789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93790       };
93791     } catch (Dali::DaliException e) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93794       };
93795     } catch (...) {
93796       {
93797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93798       };
93799     }
93800   }
93801
93802   jresult = (unsigned long)result;
93803   return jresult;
93804 }
93805
93806
93807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93808   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93809   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93810
93811   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93812   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93813   {
93814     try {
93815       (arg1)->reserve(arg2);
93816     } catch (std::out_of_range& e) {
93817       {
93818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93819       };
93820     } catch (std::exception& e) {
93821       {
93822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93823       };
93824     } catch (Dali::DaliException e) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93827       };
93828     } catch (...) {
93829       {
93830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93831       };
93832     }
93833   }
93834
93835 }
93836
93837
93838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93839   void * jresult ;
93840   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93841
93842   {
93843     try {
93844       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93852       };
93853     } catch (Dali::DaliException e) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93856       };
93857     } catch (...) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93860       };
93861     }
93862   }
93863
93864   jresult = (void *)result;
93865   return jresult;
93866 }
93867
93868
93869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93870   void * jresult ;
93871   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93872   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93873
93874   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93875   if (!arg1) {
93876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93877     return 0;
93878   }
93879   {
93880     try {
93881       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);
93882     } catch (std::out_of_range& e) {
93883       {
93884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93885       };
93886     } catch (std::exception& e) {
93887       {
93888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93889       };
93890     } catch (Dali::DaliException e) {
93891       {
93892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93893       };
93894     } catch (...) {
93895       {
93896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93897       };
93898     }
93899   }
93900
93901   jresult = (void *)result;
93902   return jresult;
93903 }
93904
93905
93906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93907   void * jresult ;
93908   int arg1 ;
93909   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93910
93911   arg1 = (int)jarg1;
93912   {
93913     try {
93914       try {
93915         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);
93916       }
93917       catch(std::out_of_range &_e) {
93918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93919         return 0;
93920       }
93921
93922     } catch (std::out_of_range& e) {
93923       {
93924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93925       };
93926     } catch (std::exception& e) {
93927       {
93928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93929       };
93930     } catch (Dali::DaliException e) {
93931       {
93932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93933       };
93934     } catch (...) {
93935       {
93936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93937       };
93938     }
93939   }
93940
93941   jresult = (void *)result;
93942   return jresult;
93943 }
93944
93945
93946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93947   void * jresult ;
93948   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93949   int arg2 ;
93950   std::pair< unsigned int,Dali::Actor > result;
93951
93952   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93953   arg2 = (int)jarg2;
93954   {
93955     try {
93956       try {
93957         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93958       }
93959       catch(std::out_of_range &_e) {
93960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93961         return 0;
93962       }
93963
93964     } catch (std::out_of_range& e) {
93965       {
93966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93967       };
93968     } catch (std::exception& e) {
93969       {
93970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93971       };
93972     } catch (Dali::DaliException e) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93975       };
93976     } catch (...) {
93977       {
93978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93979       };
93980     }
93981   }
93982
93983   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93984   return jresult;
93985 }
93986
93987
93988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93989   void * jresult ;
93990   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93991   int arg2 ;
93992   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93993
93994   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93995   arg2 = (int)jarg2;
93996   {
93997     try {
93998       try {
93999         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94000       }
94001       catch(std::out_of_range &_e) {
94002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94003         return 0;
94004       }
94005
94006     } catch (std::out_of_range& e) {
94007       {
94008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94009       };
94010     } catch (std::exception& e) {
94011       {
94012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94013       };
94014     } catch (Dali::DaliException e) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94017       };
94018     } catch (...) {
94019       {
94020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94021       };
94022     }
94023   }
94024
94025   jresult = (void *)result;
94026   return jresult;
94027 }
94028
94029
94030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94031   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94032   int arg2 ;
94033   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94034
94035   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94036   arg2 = (int)jarg2;
94037   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94038   if (!arg3) {
94039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94040     return ;
94041   }
94042   {
94043     try {
94044       try {
94045         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);
94046       }
94047       catch(std::out_of_range &_e) {
94048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94049         return ;
94050       }
94051
94052     } catch (std::out_of_range& e) {
94053       {
94054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (std::exception& e) {
94057       {
94058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94059       };
94060     } catch (Dali::DaliException e) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94063       };
94064     } catch (...) {
94065       {
94066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94067       };
94068     }
94069   }
94070
94071 }
94072
94073
94074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94075   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94076   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94077
94078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94079   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94080   if (!arg2) {
94081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94082     return ;
94083   }
94084   {
94085     try {
94086       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);
94087     } catch (std::out_of_range& e) {
94088       {
94089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94090       };
94091     } catch (std::exception& e) {
94092       {
94093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94094       };
94095     } catch (Dali::DaliException e) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94098       };
94099     } catch (...) {
94100       {
94101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94102       };
94103     }
94104   }
94105
94106 }
94107
94108
94109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94110   void * jresult ;
94111   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94112   int arg2 ;
94113   int arg3 ;
94114   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94115
94116   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94117   arg2 = (int)jarg2;
94118   arg3 = (int)jarg3;
94119   {
94120     try {
94121       try {
94122         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);
94123       }
94124       catch(std::out_of_range &_e) {
94125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94126         return 0;
94127       }
94128       catch(std::invalid_argument &_e) {
94129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94130         return 0;
94131       }
94132
94133     } catch (std::out_of_range& e) {
94134       {
94135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94136       };
94137     } catch (std::exception& e) {
94138       {
94139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94140       };
94141     } catch (Dali::DaliException e) {
94142       {
94143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94144       };
94145     } catch (...) {
94146       {
94147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94148       };
94149     }
94150   }
94151
94152   jresult = (void *)result;
94153   return jresult;
94154 }
94155
94156
94157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94158   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94159   int arg2 ;
94160   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94161
94162   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94163   arg2 = (int)jarg2;
94164   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94165   if (!arg3) {
94166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94167     return ;
94168   }
94169   {
94170     try {
94171       try {
94172         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);
94173       }
94174       catch(std::out_of_range &_e) {
94175         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94176         return ;
94177       }
94178
94179     } catch (std::out_of_range& e) {
94180       {
94181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94182       };
94183     } catch (std::exception& e) {
94184       {
94185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94186       };
94187     } catch (Dali::DaliException e) {
94188       {
94189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94190       };
94191     } catch (...) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94194       };
94195     }
94196   }
94197
94198 }
94199
94200
94201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94202   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94203   int arg2 ;
94204   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94205
94206   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94207   arg2 = (int)jarg2;
94208   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94209   if (!arg3) {
94210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94211     return ;
94212   }
94213   {
94214     try {
94215       try {
94216         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);
94217       }
94218       catch(std::out_of_range &_e) {
94219         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94220         return ;
94221       }
94222
94223     } catch (std::out_of_range& e) {
94224       {
94225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94226       };
94227     } catch (std::exception& e) {
94228       {
94229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94230       };
94231     } catch (Dali::DaliException e) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94234       };
94235     } catch (...) {
94236       {
94237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94238       };
94239     }
94240   }
94241
94242 }
94243
94244
94245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94246   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94247   int arg2 ;
94248
94249   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94250   arg2 = (int)jarg2;
94251   {
94252     try {
94253       try {
94254         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94255       }
94256       catch(std::out_of_range &_e) {
94257         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94258         return ;
94259       }
94260
94261     } catch (std::out_of_range& e) {
94262       {
94263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94264       };
94265     } catch (std::exception& e) {
94266       {
94267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94268       };
94269     } catch (Dali::DaliException e) {
94270       {
94271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94272       };
94273     } catch (...) {
94274       {
94275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94276       };
94277     }
94278   }
94279
94280 }
94281
94282
94283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94284   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94285   int arg2 ;
94286   int arg3 ;
94287
94288   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94289   arg2 = (int)jarg2;
94290   arg3 = (int)jarg3;
94291   {
94292     try {
94293       try {
94294         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94295       }
94296       catch(std::out_of_range &_e) {
94297         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94298         return ;
94299       }
94300       catch(std::invalid_argument &_e) {
94301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94302         return ;
94303       }
94304
94305     } catch (std::out_of_range& e) {
94306       {
94307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94308       };
94309     } catch (std::exception& e) {
94310       {
94311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94312       };
94313     } catch (Dali::DaliException e) {
94314       {
94315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94316       };
94317     } catch (...) {
94318       {
94319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94320       };
94321     }
94322   }
94323
94324 }
94325
94326
94327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94328   void * jresult ;
94329   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94330   int arg2 ;
94331   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94332
94333   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94334   if (!arg1) {
94335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94336     return 0;
94337   }
94338   arg2 = (int)jarg2;
94339   {
94340     try {
94341       try {
94342         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);
94343       }
94344       catch(std::out_of_range &_e) {
94345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94346         return 0;
94347       }
94348
94349     } catch (std::out_of_range& e) {
94350       {
94351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94352       };
94353     } catch (std::exception& e) {
94354       {
94355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94356       };
94357     } catch (Dali::DaliException e) {
94358       {
94359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94360       };
94361     } catch (...) {
94362       {
94363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94364       };
94365     }
94366   }
94367
94368   jresult = (void *)result;
94369   return jresult;
94370 }
94371
94372
94373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94374   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94375
94376   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94377   {
94378     try {
94379       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94380     } catch (std::out_of_range& e) {
94381       {
94382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (std::exception& e) {
94385       {
94386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94387       };
94388     } catch (Dali::DaliException e) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94391       };
94392     } catch (...) {
94393       {
94394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94395       };
94396     }
94397   }
94398
94399 }
94400
94401
94402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94403   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94404   int arg2 ;
94405   int arg3 ;
94406
94407   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94408   arg2 = (int)jarg2;
94409   arg3 = (int)jarg3;
94410   {
94411     try {
94412       try {
94413         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94414       }
94415       catch(std::out_of_range &_e) {
94416         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94417         return ;
94418       }
94419       catch(std::invalid_argument &_e) {
94420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94421         return ;
94422       }
94423
94424     } catch (std::out_of_range& e) {
94425       {
94426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94427       };
94428     } catch (std::exception& e) {
94429       {
94430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94431       };
94432     } catch (Dali::DaliException e) {
94433       {
94434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94435       };
94436     } catch (...) {
94437       {
94438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94439       };
94440     }
94441   }
94442
94443 }
94444
94445
94446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94447   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94448   int arg2 ;
94449   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94450
94451   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94452   arg2 = (int)jarg2;
94453   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94454   if (!arg3) {
94455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94456     return ;
94457   }
94458   {
94459     try {
94460       try {
94461         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);
94462       }
94463       catch(std::out_of_range &_e) {
94464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94465         return ;
94466       }
94467
94468     } catch (std::out_of_range& e) {
94469       {
94470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94471       };
94472     } catch (std::exception& e) {
94473       {
94474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94475       };
94476     } catch (Dali::DaliException e) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94479       };
94480     } catch (...) {
94481       {
94482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94483       };
94484     }
94485   }
94486
94487 }
94488
94489
94490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94491   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94492
94493   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94494   {
94495     try {
94496       delete arg1;
94497     } catch (std::out_of_range& e) {
94498       {
94499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94500       };
94501     } catch (std::exception& e) {
94502       {
94503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94504       };
94505     } catch (Dali::DaliException e) {
94506       {
94507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94508       };
94509     } catch (...) {
94510       {
94511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94512       };
94513     }
94514   }
94515
94516 }
94517
94518
94519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94520   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94521
94522   arg1 = (std::vector< Dali::Actor > *)jarg1;
94523   {
94524     try {
94525       (arg1)->clear();
94526     } catch (std::out_of_range& e) {
94527       {
94528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (std::exception& e) {
94531       {
94532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94533       };
94534     } catch (Dali::DaliException e) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94537       };
94538     } catch (...) {
94539       {
94540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94541       };
94542     }
94543   }
94544
94545 }
94546
94547
94548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94549   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94550   Dali::Actor *arg2 = 0 ;
94551
94552   arg1 = (std::vector< Dali::Actor > *)jarg1;
94553   arg2 = (Dali::Actor *)jarg2;
94554   if (!arg2) {
94555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94556     return ;
94557   }
94558   {
94559     try {
94560       (arg1)->push_back((Dali::Actor const &)*arg2);
94561     } catch (std::out_of_range& e) {
94562       {
94563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94564       };
94565     } catch (std::exception& e) {
94566       {
94567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94568       };
94569     } catch (Dali::DaliException e) {
94570       {
94571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94572       };
94573     } catch (...) {
94574       {
94575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94576       };
94577     }
94578   }
94579
94580 }
94581
94582
94583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94584   unsigned long jresult ;
94585   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94586   std::vector< Dali::Actor >::size_type result;
94587
94588   arg1 = (std::vector< Dali::Actor > *)jarg1;
94589   {
94590     try {
94591       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94592     } catch (std::out_of_range& e) {
94593       {
94594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94595       };
94596     } catch (std::exception& e) {
94597       {
94598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94599       };
94600     } catch (Dali::DaliException e) {
94601       {
94602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94603       };
94604     } catch (...) {
94605       {
94606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94607       };
94608     }
94609   }
94610
94611   jresult = (unsigned long)result;
94612   return jresult;
94613 }
94614
94615
94616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94617   unsigned long jresult ;
94618   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94619   std::vector< Dali::Actor >::size_type result;
94620
94621   arg1 = (std::vector< Dali::Actor > *)jarg1;
94622   {
94623     try {
94624       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94625     } catch (std::out_of_range& e) {
94626       {
94627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (std::exception& e) {
94630       {
94631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94632       };
94633     } catch (Dali::DaliException e) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94636       };
94637     } catch (...) {
94638       {
94639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94640       };
94641     }
94642   }
94643
94644   jresult = (unsigned long)result;
94645   return jresult;
94646 }
94647
94648
94649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94650   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94651   std::vector< Dali::Actor >::size_type arg2 ;
94652
94653   arg1 = (std::vector< Dali::Actor > *)jarg1;
94654   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94655   {
94656     try {
94657       (arg1)->reserve(arg2);
94658     } catch (std::out_of_range& e) {
94659       {
94660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94661       };
94662     } catch (std::exception& e) {
94663       {
94664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94665       };
94666     } catch (Dali::DaliException e) {
94667       {
94668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94669       };
94670     } catch (...) {
94671       {
94672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94673       };
94674     }
94675   }
94676
94677 }
94678
94679
94680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94681   void * jresult ;
94682   std::vector< Dali::Actor > *result = 0 ;
94683
94684   {
94685     try {
94686       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94687     } catch (std::out_of_range& e) {
94688       {
94689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94690       };
94691     } catch (std::exception& e) {
94692       {
94693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94694       };
94695     } catch (Dali::DaliException e) {
94696       {
94697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94698       };
94699     } catch (...) {
94700       {
94701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94702       };
94703     }
94704   }
94705
94706   jresult = (void *)result;
94707   return jresult;
94708 }
94709
94710
94711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94712   void * jresult ;
94713   std::vector< Dali::Actor > *arg1 = 0 ;
94714   std::vector< Dali::Actor > *result = 0 ;
94715
94716   arg1 = (std::vector< Dali::Actor > *)jarg1;
94717   if (!arg1) {
94718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94719     return 0;
94720   }
94721   {
94722     try {
94723       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94724     } catch (std::out_of_range& e) {
94725       {
94726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94727       };
94728     } catch (std::exception& e) {
94729       {
94730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94731       };
94732     } catch (Dali::DaliException e) {
94733       {
94734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94735       };
94736     } catch (...) {
94737       {
94738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94739       };
94740     }
94741   }
94742
94743   jresult = (void *)result;
94744   return jresult;
94745 }
94746
94747
94748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94749   void * jresult ;
94750   int arg1 ;
94751   std::vector< Dali::Actor > *result = 0 ;
94752
94753   arg1 = (int)jarg1;
94754   {
94755     try {
94756       try {
94757         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94758       }
94759       catch(std::out_of_range &_e) {
94760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94761         return 0;
94762       }
94763
94764     } catch (std::out_of_range& e) {
94765       {
94766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94767       };
94768     } catch (std::exception& e) {
94769       {
94770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94771       };
94772     } catch (Dali::DaliException e) {
94773       {
94774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94775       };
94776     } catch (...) {
94777       {
94778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94779       };
94780     }
94781   }
94782
94783   jresult = (void *)result;
94784   return jresult;
94785 }
94786
94787
94788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94789   void * jresult ;
94790   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94791   int arg2 ;
94792   Dali::Actor result;
94793
94794   arg1 = (std::vector< Dali::Actor > *)jarg1;
94795   arg2 = (int)jarg2;
94796   {
94797     try {
94798       try {
94799         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94800       }
94801       catch(std::out_of_range &_e) {
94802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94803         return 0;
94804       }
94805
94806     } catch (std::out_of_range& e) {
94807       {
94808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94809       };
94810     } catch (std::exception& e) {
94811       {
94812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94813       };
94814     } catch (Dali::DaliException e) {
94815       {
94816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94817       };
94818     } catch (...) {
94819       {
94820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94821       };
94822     }
94823   }
94824
94825   jresult = new Dali::Actor((const Dali::Actor &)result);
94826   return jresult;
94827 }
94828
94829
94830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94831   void * jresult ;
94832   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94833   int arg2 ;
94834   Dali::Actor *result = 0 ;
94835
94836   arg1 = (std::vector< Dali::Actor > *)jarg1;
94837   arg2 = (int)jarg2;
94838   {
94839     try {
94840       try {
94841         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94842       }
94843       catch(std::out_of_range &_e) {
94844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94845         return 0;
94846       }
94847
94848     } catch (std::out_of_range& e) {
94849       {
94850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94851       };
94852     } catch (std::exception& e) {
94853       {
94854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94855       };
94856     } catch (Dali::DaliException e) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94859       };
94860     } catch (...) {
94861       {
94862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94863       };
94864     }
94865   }
94866
94867   jresult = (void *)result;
94868   return jresult;
94869 }
94870
94871
94872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94873   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94874   int arg2 ;
94875   Dali::Actor *arg3 = 0 ;
94876
94877   arg1 = (std::vector< Dali::Actor > *)jarg1;
94878   arg2 = (int)jarg2;
94879   arg3 = (Dali::Actor *)jarg3;
94880   if (!arg3) {
94881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94882     return ;
94883   }
94884   {
94885     try {
94886       try {
94887         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94888       }
94889       catch(std::out_of_range &_e) {
94890         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94891         return ;
94892       }
94893
94894     } catch (std::out_of_range& e) {
94895       {
94896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94897       };
94898     } catch (std::exception& e) {
94899       {
94900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94901       };
94902     } catch (Dali::DaliException e) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94905       };
94906     } catch (...) {
94907       {
94908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94909       };
94910     }
94911   }
94912
94913 }
94914
94915
94916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94917   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94918   std::vector< Dali::Actor > *arg2 = 0 ;
94919
94920   arg1 = (std::vector< Dali::Actor > *)jarg1;
94921   arg2 = (std::vector< Dali::Actor > *)jarg2;
94922   if (!arg2) {
94923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94924     return ;
94925   }
94926   {
94927     try {
94928       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94929     } catch (std::out_of_range& e) {
94930       {
94931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94932       };
94933     } catch (std::exception& e) {
94934       {
94935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94936       };
94937     } catch (Dali::DaliException e) {
94938       {
94939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94940       };
94941     } catch (...) {
94942       {
94943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94944       };
94945     }
94946   }
94947
94948 }
94949
94950
94951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94952   void * jresult ;
94953   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94954   int arg2 ;
94955   int arg3 ;
94956   std::vector< Dali::Actor > *result = 0 ;
94957
94958   arg1 = (std::vector< Dali::Actor > *)jarg1;
94959   arg2 = (int)jarg2;
94960   arg3 = (int)jarg3;
94961   {
94962     try {
94963       try {
94964         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94965       }
94966       catch(std::out_of_range &_e) {
94967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94968         return 0;
94969       }
94970       catch(std::invalid_argument &_e) {
94971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94972         return 0;
94973       }
94974
94975     } catch (std::out_of_range& e) {
94976       {
94977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94978       };
94979     } catch (std::exception& e) {
94980       {
94981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94982       };
94983     } catch (Dali::DaliException e) {
94984       {
94985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94986       };
94987     } catch (...) {
94988       {
94989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94990       };
94991     }
94992   }
94993
94994   jresult = (void *)result;
94995   return jresult;
94996 }
94997
94998
94999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95000   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95001   int arg2 ;
95002   Dali::Actor *arg3 = 0 ;
95003
95004   arg1 = (std::vector< Dali::Actor > *)jarg1;
95005   arg2 = (int)jarg2;
95006   arg3 = (Dali::Actor *)jarg3;
95007   if (!arg3) {
95008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95009     return ;
95010   }
95011   {
95012     try {
95013       try {
95014         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95015       }
95016       catch(std::out_of_range &_e) {
95017         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95018         return ;
95019       }
95020
95021     } catch (std::out_of_range& e) {
95022       {
95023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95024       };
95025     } catch (std::exception& e) {
95026       {
95027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95028       };
95029     } catch (Dali::DaliException e) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95032       };
95033     } catch (...) {
95034       {
95035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95036       };
95037     }
95038   }
95039
95040 }
95041
95042
95043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95044   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95045   int arg2 ;
95046   std::vector< Dali::Actor > *arg3 = 0 ;
95047
95048   arg1 = (std::vector< Dali::Actor > *)jarg1;
95049   arg2 = (int)jarg2;
95050   arg3 = (std::vector< Dali::Actor > *)jarg3;
95051   if (!arg3) {
95052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95053     return ;
95054   }
95055   {
95056     try {
95057       try {
95058         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95059       }
95060       catch(std::out_of_range &_e) {
95061         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95062         return ;
95063       }
95064
95065     } catch (std::out_of_range& e) {
95066       {
95067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95068       };
95069     } catch (std::exception& e) {
95070       {
95071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95072       };
95073     } catch (Dali::DaliException e) {
95074       {
95075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95076       };
95077     } catch (...) {
95078       {
95079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95080       };
95081     }
95082   }
95083
95084 }
95085
95086
95087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95088   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95089   int arg2 ;
95090
95091   arg1 = (std::vector< Dali::Actor > *)jarg1;
95092   arg2 = (int)jarg2;
95093   {
95094     try {
95095       try {
95096         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95097       }
95098       catch(std::out_of_range &_e) {
95099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95100         return ;
95101       }
95102
95103     } catch (std::out_of_range& e) {
95104       {
95105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95106       };
95107     } catch (std::exception& e) {
95108       {
95109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95110       };
95111     } catch (Dali::DaliException e) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95114       };
95115     } catch (...) {
95116       {
95117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95118       };
95119     }
95120   }
95121
95122 }
95123
95124
95125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95126   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95127   int arg2 ;
95128   int arg3 ;
95129
95130   arg1 = (std::vector< Dali::Actor > *)jarg1;
95131   arg2 = (int)jarg2;
95132   arg3 = (int)jarg3;
95133   {
95134     try {
95135       try {
95136         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95137       }
95138       catch(std::out_of_range &_e) {
95139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95140         return ;
95141       }
95142       catch(std::invalid_argument &_e) {
95143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95144         return ;
95145       }
95146
95147     } catch (std::out_of_range& e) {
95148       {
95149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95150       };
95151     } catch (std::exception& e) {
95152       {
95153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95154       };
95155     } catch (Dali::DaliException e) {
95156       {
95157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95158       };
95159     } catch (...) {
95160       {
95161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95162       };
95163     }
95164   }
95165
95166 }
95167
95168
95169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95170   void * jresult ;
95171   Dali::Actor *arg1 = 0 ;
95172   int arg2 ;
95173   std::vector< Dali::Actor > *result = 0 ;
95174
95175   arg1 = (Dali::Actor *)jarg1;
95176   if (!arg1) {
95177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95178     return 0;
95179   }
95180   arg2 = (int)jarg2;
95181   {
95182     try {
95183       try {
95184         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95185       }
95186       catch(std::out_of_range &_e) {
95187         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95188         return 0;
95189       }
95190
95191     } catch (std::out_of_range& e) {
95192       {
95193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95194       };
95195     } catch (std::exception& e) {
95196       {
95197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95198       };
95199     } catch (Dali::DaliException e) {
95200       {
95201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95202       };
95203     } catch (...) {
95204       {
95205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95206       };
95207     }
95208   }
95209
95210   jresult = (void *)result;
95211   return jresult;
95212 }
95213
95214
95215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95216   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95217
95218   arg1 = (std::vector< Dali::Actor > *)jarg1;
95219   {
95220     try {
95221       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95222     } catch (std::out_of_range& e) {
95223       {
95224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95225       };
95226     } catch (std::exception& e) {
95227       {
95228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95229       };
95230     } catch (Dali::DaliException e) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95233       };
95234     } catch (...) {
95235       {
95236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95237       };
95238     }
95239   }
95240
95241 }
95242
95243
95244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95245   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95246   int arg2 ;
95247   int arg3 ;
95248
95249   arg1 = (std::vector< Dali::Actor > *)jarg1;
95250   arg2 = (int)jarg2;
95251   arg3 = (int)jarg3;
95252   {
95253     try {
95254       try {
95255         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95256       }
95257       catch(std::out_of_range &_e) {
95258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95259         return ;
95260       }
95261       catch(std::invalid_argument &_e) {
95262         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95263         return ;
95264       }
95265
95266     } catch (std::out_of_range& e) {
95267       {
95268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95269       };
95270     } catch (std::exception& e) {
95271       {
95272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95273       };
95274     } catch (Dali::DaliException e) {
95275       {
95276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95277       };
95278     } catch (...) {
95279       {
95280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95281       };
95282     }
95283   }
95284
95285 }
95286
95287
95288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95289   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95290   int arg2 ;
95291   std::vector< Dali::Actor > *arg3 = 0 ;
95292
95293   arg1 = (std::vector< Dali::Actor > *)jarg1;
95294   arg2 = (int)jarg2;
95295   arg3 = (std::vector< Dali::Actor > *)jarg3;
95296   if (!arg3) {
95297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95298     return ;
95299   }
95300   {
95301     try {
95302       try {
95303         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95304       }
95305       catch(std::out_of_range &_e) {
95306         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95307         return ;
95308       }
95309
95310     } catch (std::out_of_range& e) {
95311       {
95312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95313       };
95314     } catch (std::exception& e) {
95315       {
95316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95317       };
95318     } catch (Dali::DaliException e) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95321       };
95322     } catch (...) {
95323       {
95324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95325       };
95326     }
95327   }
95328
95329 }
95330
95331
95332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95333   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95334
95335   arg1 = (std::vector< Dali::Actor > *)jarg1;
95336   {
95337     try {
95338       delete arg1;
95339     } catch (std::out_of_range& e) {
95340       {
95341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95342       };
95343     } catch (std::exception& e) {
95344       {
95345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95346       };
95347     } catch (Dali::DaliException e) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95350       };
95351     } catch (...) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95354       };
95355     }
95356   }
95357
95358 }
95359
95360
95361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95362   unsigned int jresult ;
95363   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95364   bool result;
95365
95366   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95367   {
95368     try {
95369       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95370     } catch (std::out_of_range& e) {
95371       {
95372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95373       };
95374     } catch (std::exception& e) {
95375       {
95376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95377       };
95378     } catch (Dali::DaliException e) {
95379       {
95380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95381       };
95382     } catch (...) {
95383       {
95384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95385       };
95386     }
95387   }
95388
95389   jresult = result;
95390   return jresult;
95391 }
95392
95393
95394 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95395   unsigned long jresult ;
95396   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95397   std::size_t result;
95398
95399   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95400   {
95401     try {
95402       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95403     } catch (std::out_of_range& e) {
95404       {
95405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95406       };
95407     } catch (std::exception& e) {
95408       {
95409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95410       };
95411     } catch (Dali::DaliException e) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95414       };
95415     } catch (...) {
95416       {
95417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95418       };
95419     }
95420   }
95421
95422   jresult = (unsigned long)result;
95423   return jresult;
95424 }
95425
95426
95427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95428   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95429   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95430
95431   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95432   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95433   {
95434     try {
95435       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95436     } catch (std::out_of_range& e) {
95437       {
95438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95439       };
95440     } catch (std::exception& e) {
95441       {
95442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95443       };
95444     } catch (Dali::DaliException e) {
95445       {
95446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95447       };
95448     } catch (...) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95451       };
95452     }
95453   }
95454
95455 }
95456
95457
95458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95459   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95460   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95461
95462   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95463   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95464   {
95465     try {
95466       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95467     } catch (std::out_of_range& e) {
95468       {
95469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (std::exception& e) {
95472       {
95473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (Dali::DaliException e) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95482       };
95483     }
95484   }
95485
95486 }
95487
95488
95489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95490   unsigned int jresult ;
95491   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95492   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95493   bool result;
95494
95495   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95496   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95497   if (!arg2) {
95498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95499     return 0;
95500   }
95501   {
95502     try {
95503       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95504     } catch (std::out_of_range& e) {
95505       {
95506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95507       };
95508     } catch (std::exception& e) {
95509       {
95510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95511       };
95512     } catch (Dali::DaliException e) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95515       };
95516     } catch (...) {
95517       {
95518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95519       };
95520     }
95521   }
95522
95523   jresult = result;
95524   return jresult;
95525 }
95526
95527
95528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95529   void * jresult ;
95530   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95531
95532   {
95533     try {
95534       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95535     } catch (std::out_of_range& e) {
95536       {
95537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95538       };
95539     } catch (std::exception& e) {
95540       {
95541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95542       };
95543     } catch (Dali::DaliException e) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95546       };
95547     } catch (...) {
95548       {
95549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95550       };
95551     }
95552   }
95553
95554   jresult = (void *)result;
95555   return jresult;
95556 }
95557
95558
95559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95560   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95561
95562   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95563   {
95564     try {
95565       delete arg1;
95566     } catch (std::out_of_range& e) {
95567       {
95568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95569       };
95570     } catch (std::exception& e) {
95571       {
95572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95573       };
95574     } catch (Dali::DaliException e) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95577       };
95578     } catch (...) {
95579       {
95580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95581       };
95582     }
95583   }
95584
95585 }
95586
95587
95588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95589   unsigned int jresult ;
95590   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95591   bool result;
95592
95593   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95594   {
95595     try {
95596       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);
95597     } catch (std::out_of_range& e) {
95598       {
95599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95600       };
95601     } catch (std::exception& e) {
95602       {
95603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95604       };
95605     } catch (Dali::DaliException e) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95608       };
95609     } catch (...) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95612       };
95613     }
95614   }
95615
95616   jresult = result;
95617   return jresult;
95618 }
95619
95620
95621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95622   unsigned long jresult ;
95623   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95624   std::size_t result;
95625
95626   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95627   {
95628     try {
95629       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);
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95637       };
95638     } catch (Dali::DaliException e) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95641       };
95642     } catch (...) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95645       };
95646     }
95647   }
95648
95649   jresult = (unsigned long)result;
95650   return jresult;
95651 }
95652
95653
95654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95655   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95656   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95657
95658   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95659   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95660   {
95661     try {
95662       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95663     } catch (std::out_of_range& e) {
95664       {
95665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95666       };
95667     } catch (std::exception& e) {
95668       {
95669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95670       };
95671     } catch (Dali::DaliException e) {
95672       {
95673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95674       };
95675     } catch (...) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95678       };
95679     }
95680   }
95681
95682 }
95683
95684
95685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95686   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95687   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95688
95689   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95690   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95691   {
95692     try {
95693       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95694     } catch (std::out_of_range& e) {
95695       {
95696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95697       };
95698     } catch (std::exception& e) {
95699       {
95700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95701       };
95702     } catch (Dali::DaliException e) {
95703       {
95704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95705       };
95706     } catch (...) {
95707       {
95708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95709       };
95710     }
95711   }
95712
95713 }
95714
95715
95716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95717   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95718   Dali::Actor arg2 ;
95719   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95720   Dali::Actor *argp2 ;
95721
95722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95723   argp2 = (Dali::Actor *)jarg2;
95724   if (!argp2) {
95725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95726     return ;
95727   }
95728   arg2 = *argp2;
95729   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95730   {
95731     try {
95732       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95733     } catch (std::out_of_range& e) {
95734       {
95735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95736       };
95737     } catch (std::exception& e) {
95738       {
95739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95740       };
95741     } catch (Dali::DaliException e) {
95742       {
95743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95744       };
95745     } catch (...) {
95746       {
95747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95748       };
95749     }
95750   }
95751
95752 }
95753
95754
95755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95756   void * jresult ;
95757   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95758
95759   {
95760     try {
95761       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95762     } catch (std::out_of_range& e) {
95763       {
95764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95765       };
95766     } catch (std::exception& e) {
95767       {
95768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95769       };
95770     } catch (Dali::DaliException e) {
95771       {
95772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95773       };
95774     } catch (...) {
95775       {
95776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95777       };
95778     }
95779   }
95780
95781   jresult = (void *)result;
95782   return jresult;
95783 }
95784
95785
95786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95787   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95788
95789   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95790   {
95791     try {
95792       delete arg1;
95793     } catch (std::out_of_range& e) {
95794       {
95795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95796       };
95797     } catch (std::exception& e) {
95798       {
95799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95800       };
95801     } catch (Dali::DaliException e) {
95802       {
95803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95804       };
95805     } catch (...) {
95806       {
95807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95808       };
95809     }
95810   }
95811
95812 }
95813
95814
95815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95816   unsigned int jresult ;
95817   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95818   bool result;
95819
95820   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95821   {
95822     try {
95823       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95824     } catch (std::out_of_range& e) {
95825       {
95826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95827       };
95828     } catch (std::exception& e) {
95829       {
95830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95831       };
95832     } catch (Dali::DaliException e) {
95833       {
95834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95835       };
95836     } catch (...) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95839       };
95840     }
95841   }
95842
95843   jresult = result;
95844   return jresult;
95845 }
95846
95847
95848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95849   unsigned long jresult ;
95850   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95851   std::size_t result;
95852
95853   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95854   {
95855     try {
95856       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95857     } catch (std::out_of_range& e) {
95858       {
95859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95860       };
95861     } catch (std::exception& e) {
95862       {
95863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95864       };
95865     } catch (Dali::DaliException e) {
95866       {
95867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95868       };
95869     } catch (...) {
95870       {
95871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95872       };
95873     }
95874   }
95875
95876   jresult = (unsigned long)result;
95877   return jresult;
95878 }
95879
95880
95881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95882   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95883   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95884
95885   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95886   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95887   {
95888     try {
95889       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95890     } catch (std::out_of_range& e) {
95891       {
95892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95893       };
95894     } catch (std::exception& e) {
95895       {
95896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95897       };
95898     } catch (Dali::DaliException e) {
95899       {
95900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95901       };
95902     } catch (...) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95905       };
95906     }
95907   }
95908
95909 }
95910
95911
95912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95913   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95914   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95915
95916   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95917   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95918   {
95919     try {
95920       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95921     } catch (std::out_of_range& e) {
95922       {
95923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95924       };
95925     } catch (std::exception& e) {
95926       {
95927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95928       };
95929     } catch (Dali::DaliException e) {
95930       {
95931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95932       };
95933     } catch (...) {
95934       {
95935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95936       };
95937     }
95938   }
95939
95940 }
95941
95942
95943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95944   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95945   Dali::Actor arg2 ;
95946   Dali::Actor arg3 ;
95947   Dali::Actor *argp2 ;
95948   Dali::Actor *argp3 ;
95949
95950   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95951   argp2 = (Dali::Actor *)jarg2;
95952   if (!argp2) {
95953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95954     return ;
95955   }
95956   arg2 = *argp2;
95957   argp3 = (Dali::Actor *)jarg3;
95958   if (!argp3) {
95959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95960     return ;
95961   }
95962   arg3 = *argp3;
95963   {
95964     try {
95965       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95966     } catch (std::out_of_range& e) {
95967       {
95968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95969       };
95970     } catch (std::exception& e) {
95971       {
95972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95973       };
95974     } catch (Dali::DaliException e) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95977       };
95978     } catch (...) {
95979       {
95980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95981       };
95982     }
95983   }
95984
95985 }
95986
95987
95988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95989   void * jresult ;
95990   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95991
95992   {
95993     try {
95994       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95995     } catch (std::out_of_range& e) {
95996       {
95997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95998       };
95999     } catch (std::exception& e) {
96000       {
96001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96002       };
96003     } catch (Dali::DaliException e) {
96004       {
96005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96006       };
96007     } catch (...) {
96008       {
96009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96010       };
96011     }
96012   }
96013
96014   jresult = (void *)result;
96015   return jresult;
96016 }
96017
96018
96019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96020   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96021
96022   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96023   {
96024     try {
96025       delete arg1;
96026     } catch (std::out_of_range& e) {
96027       {
96028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96029       };
96030     } catch (std::exception& e) {
96031       {
96032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96033       };
96034     } catch (Dali::DaliException e) {
96035       {
96036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96037       };
96038     } catch (...) {
96039       {
96040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96041       };
96042     }
96043   }
96044
96045 }
96046
96047
96048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96049   unsigned int jresult ;
96050   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96051   bool result;
96052
96053   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96054   {
96055     try {
96056       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96057     } catch (std::out_of_range& e) {
96058       {
96059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96060       };
96061     } catch (std::exception& e) {
96062       {
96063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96064       };
96065     } catch (Dali::DaliException e) {
96066       {
96067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96068       };
96069     } catch (...) {
96070       {
96071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96072       };
96073     }
96074   }
96075
96076   jresult = result;
96077   return jresult;
96078 }
96079
96080
96081 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96082   unsigned long jresult ;
96083   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96084   std::size_t result;
96085
96086   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96087   {
96088     try {
96089       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96090     } catch (std::out_of_range& e) {
96091       {
96092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96093       };
96094     } catch (std::exception& e) {
96095       {
96096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96097       };
96098     } catch (Dali::DaliException e) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96101       };
96102     } catch (...) {
96103       {
96104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96105       };
96106     }
96107   }
96108
96109   jresult = (unsigned long)result;
96110   return jresult;
96111 }
96112
96113
96114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96115   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96116   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96117
96118   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96119   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96120   {
96121     try {
96122       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96123     } catch (std::out_of_range& e) {
96124       {
96125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (std::exception& e) {
96128       {
96129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96130       };
96131     } catch (Dali::DaliException e) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96134       };
96135     } catch (...) {
96136       {
96137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96138       };
96139     }
96140   }
96141
96142 }
96143
96144
96145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96146   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96147   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96148
96149   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96150   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96151   {
96152     try {
96153       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96154     } catch (std::out_of_range& e) {
96155       {
96156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96157       };
96158     } catch (std::exception& e) {
96159       {
96160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96161       };
96162     } catch (Dali::DaliException e) {
96163       {
96164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96165       };
96166     } catch (...) {
96167       {
96168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96169       };
96170     }
96171   }
96172
96173 }
96174
96175
96176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96177   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96178   Dali::Actor arg2 ;
96179   bool arg3 ;
96180   Dali::Actor *argp2 ;
96181
96182   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96183   argp2 = (Dali::Actor *)jarg2;
96184   if (!argp2) {
96185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96186     return ;
96187   }
96188   arg2 = *argp2;
96189   arg3 = jarg3 ? true : false;
96190   {
96191     try {
96192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96193     } catch (std::out_of_range& e) {
96194       {
96195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96196       };
96197     } catch (std::exception& e) {
96198       {
96199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96200       };
96201     } catch (Dali::DaliException e) {
96202       {
96203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96204       };
96205     } catch (...) {
96206       {
96207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96208       };
96209     }
96210   }
96211
96212 }
96213
96214
96215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96216   void * jresult ;
96217   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96218
96219   {
96220     try {
96221       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96222     } catch (std::out_of_range& e) {
96223       {
96224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96225       };
96226     } catch (std::exception& e) {
96227       {
96228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96229       };
96230     } catch (Dali::DaliException e) {
96231       {
96232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96233       };
96234     } catch (...) {
96235       {
96236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96237       };
96238     }
96239   }
96240
96241   jresult = (void *)result;
96242   return jresult;
96243 }
96244
96245
96246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96247   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96248
96249   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96250   {
96251     try {
96252       delete arg1;
96253     } catch (std::out_of_range& e) {
96254       {
96255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96256       };
96257     } catch (std::exception& e) {
96258       {
96259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96260       };
96261     } catch (Dali::DaliException e) {
96262       {
96263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96264       };
96265     } catch (...) {
96266       {
96267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96268       };
96269     }
96270   }
96271
96272 }
96273
96274
96275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96276   unsigned int jresult ;
96277   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96278   bool result;
96279
96280   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96281   {
96282     try {
96283       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);
96284     } catch (std::out_of_range& e) {
96285       {
96286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96287       };
96288     } catch (std::exception& e) {
96289       {
96290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96291       };
96292     } catch (Dali::DaliException e) {
96293       {
96294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96295       };
96296     } catch (...) {
96297       {
96298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96299       };
96300     }
96301   }
96302
96303   jresult = result;
96304   return jresult;
96305 }
96306
96307
96308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96309   unsigned long jresult ;
96310   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96311   std::size_t result;
96312
96313   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96314   {
96315     try {
96316       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);
96317     } catch (std::out_of_range& e) {
96318       {
96319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96320       };
96321     } catch (std::exception& e) {
96322       {
96323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96324       };
96325     } catch (Dali::DaliException e) {
96326       {
96327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96328       };
96329     } catch (...) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96332       };
96333     }
96334   }
96335
96336   jresult = (unsigned long)result;
96337   return jresult;
96338 }
96339
96340
96341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96342   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96343   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96344
96345   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96346   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96347   {
96348     try {
96349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96350     } catch (std::out_of_range& e) {
96351       {
96352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96353       };
96354     } catch (std::exception& e) {
96355       {
96356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96357       };
96358     } catch (Dali::DaliException e) {
96359       {
96360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96361       };
96362     } catch (...) {
96363       {
96364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96365       };
96366     }
96367   }
96368
96369 }
96370
96371
96372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96373   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96374   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96375
96376   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96377   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96378   {
96379     try {
96380       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96381     } catch (std::out_of_range& e) {
96382       {
96383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96384       };
96385     } catch (std::exception& e) {
96386       {
96387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96388       };
96389     } catch (Dali::DaliException e) {
96390       {
96391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96392       };
96393     } catch (...) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96396       };
96397     }
96398   }
96399
96400 }
96401
96402
96403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96404   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96405   Dali::Toolkit::StyleManager arg2 ;
96406   Dali::StyleChange::Type arg3 ;
96407   Dali::Toolkit::StyleManager *argp2 ;
96408
96409   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96410   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96411   if (!argp2) {
96412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96413     return ;
96414   }
96415   arg2 = *argp2;
96416   arg3 = (Dali::StyleChange::Type)jarg3;
96417   {
96418     try {
96419       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96420     } catch (std::out_of_range& e) {
96421       {
96422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96423       };
96424     } catch (std::exception& e) {
96425       {
96426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96427       };
96428     } catch (Dali::DaliException e) {
96429       {
96430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96431       };
96432     } catch (...) {
96433       {
96434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96435       };
96436     }
96437   }
96438
96439 }
96440
96441
96442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96443   void * jresult ;
96444   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96445
96446   {
96447     try {
96448       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96449     } catch (std::out_of_range& e) {
96450       {
96451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96452       };
96453     } catch (std::exception& e) {
96454       {
96455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96456       };
96457     } catch (Dali::DaliException e) {
96458       {
96459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96460       };
96461     } catch (...) {
96462       {
96463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96464       };
96465     }
96466   }
96467
96468   jresult = (void *)result;
96469   return jresult;
96470 }
96471
96472
96473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96474   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96475
96476   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96477   {
96478     try {
96479       delete arg1;
96480     } catch (std::out_of_range& e) {
96481       {
96482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96483       };
96484     } catch (std::exception& e) {
96485       {
96486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96487       };
96488     } catch (Dali::DaliException e) {
96489       {
96490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96491       };
96492     } catch (...) {
96493       {
96494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96495       };
96496     }
96497   }
96498
96499 }
96500
96501
96502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96503   unsigned int jresult ;
96504   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96505   bool result;
96506
96507   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96508   {
96509     try {
96510       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96511     } catch (std::out_of_range& e) {
96512       {
96513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96514       };
96515     } catch (std::exception& e) {
96516       {
96517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96518       };
96519     } catch (Dali::DaliException e) {
96520       {
96521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96522       };
96523     } catch (...) {
96524       {
96525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96526       };
96527     }
96528   }
96529
96530   jresult = result;
96531   return jresult;
96532 }
96533
96534
96535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96536   unsigned long jresult ;
96537   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96538   std::size_t result;
96539
96540   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96541   {
96542     try {
96543       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96544     } catch (std::out_of_range& e) {
96545       {
96546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (std::exception& e) {
96549       {
96550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96551       };
96552     } catch (Dali::DaliException e) {
96553       {
96554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96555       };
96556     } catch (...) {
96557       {
96558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96559       };
96560     }
96561   }
96562
96563   jresult = (unsigned long)result;
96564   return jresult;
96565 }
96566
96567
96568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96569   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96570   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96571
96572   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96573   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96574   {
96575     try {
96576       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96577     } catch (std::out_of_range& e) {
96578       {
96579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96580       };
96581     } catch (std::exception& e) {
96582       {
96583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96584       };
96585     } catch (Dali::DaliException e) {
96586       {
96587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96588       };
96589     } catch (...) {
96590       {
96591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96592       };
96593     }
96594   }
96595
96596 }
96597
96598
96599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96600   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96601   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96602
96603   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96604   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96605   {
96606     try {
96607       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96608     } catch (std::out_of_range& e) {
96609       {
96610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96611       };
96612     } catch (std::exception& e) {
96613       {
96614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96615       };
96616     } catch (Dali::DaliException e) {
96617       {
96618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96619       };
96620     } catch (...) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96623       };
96624     }
96625   }
96626
96627 }
96628
96629
96630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96631   unsigned int jresult ;
96632   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96633   Dali::Toolkit::Button arg2 ;
96634   Dali::Toolkit::Button *argp2 ;
96635   bool result;
96636
96637   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96638   argp2 = (Dali::Toolkit::Button *)jarg2;
96639   if (!argp2) {
96640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96641     return 0;
96642   }
96643   arg2 = *argp2;
96644   {
96645     try {
96646       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96647     } catch (std::out_of_range& e) {
96648       {
96649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96650       };
96651     } catch (std::exception& e) {
96652       {
96653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96654       };
96655     } catch (Dali::DaliException e) {
96656       {
96657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96658       };
96659     } catch (...) {
96660       {
96661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96662       };
96663     }
96664   }
96665
96666   jresult = result;
96667   return jresult;
96668 }
96669
96670
96671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96672   void * jresult ;
96673   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96674
96675   {
96676     try {
96677       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96678     } catch (std::out_of_range& e) {
96679       {
96680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96681       };
96682     } catch (std::exception& e) {
96683       {
96684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96685       };
96686     } catch (Dali::DaliException e) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96689       };
96690     } catch (...) {
96691       {
96692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96693       };
96694     }
96695   }
96696
96697   jresult = (void *)result;
96698   return jresult;
96699 }
96700
96701
96702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96703   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96704
96705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96706   {
96707     try {
96708       delete arg1;
96709     } catch (std::out_of_range& e) {
96710       {
96711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (std::exception& e) {
96714       {
96715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96716       };
96717     } catch (Dali::DaliException e) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96720       };
96721     } catch (...) {
96722       {
96723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96724       };
96725     }
96726   }
96727
96728 }
96729
96730
96731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96732   unsigned int jresult ;
96733   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96734   bool result;
96735
96736   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96737   {
96738     try {
96739       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96740     } catch (std::out_of_range& e) {
96741       {
96742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96743       };
96744     } catch (std::exception& e) {
96745       {
96746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96747       };
96748     } catch (Dali::DaliException e) {
96749       {
96750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96751       };
96752     } catch (...) {
96753       {
96754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96755       };
96756     }
96757   }
96758
96759   jresult = result;
96760   return jresult;
96761 }
96762
96763
96764 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96765   unsigned long jresult ;
96766   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96767   std::size_t result;
96768
96769   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96770   {
96771     try {
96772       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96773     } catch (std::out_of_range& e) {
96774       {
96775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96776       };
96777     } catch (std::exception& e) {
96778       {
96779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96780       };
96781     } catch (Dali::DaliException e) {
96782       {
96783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96784       };
96785     } catch (...) {
96786       {
96787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96788       };
96789     }
96790   }
96791
96792   jresult = (unsigned long)result;
96793   return jresult;
96794 }
96795
96796
96797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96798   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96799   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96800
96801   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96802   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96803   {
96804     try {
96805       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96806     } catch (std::out_of_range& e) {
96807       {
96808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96809       };
96810     } catch (std::exception& e) {
96811       {
96812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96813       };
96814     } catch (Dali::DaliException e) {
96815       {
96816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96817       };
96818     } catch (...) {
96819       {
96820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96821       };
96822     }
96823   }
96824
96825 }
96826
96827
96828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96829   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96830   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96831
96832   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96833   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96834   {
96835     try {
96836       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96837     } catch (std::out_of_range& e) {
96838       {
96839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96840       };
96841     } catch (std::exception& e) {
96842       {
96843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96844       };
96845     } catch (Dali::DaliException e) {
96846       {
96847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96848       };
96849     } catch (...) {
96850       {
96851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96852       };
96853     }
96854   }
96855
96856 }
96857
96858
96859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96860   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96861   Dali::Toolkit::GaussianBlurView arg2 ;
96862   Dali::Toolkit::GaussianBlurView *argp2 ;
96863
96864   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96865   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96866   if (!argp2) {
96867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96868     return ;
96869   }
96870   arg2 = *argp2;
96871   {
96872     try {
96873       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96874     } catch (std::out_of_range& e) {
96875       {
96876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96877       };
96878     } catch (std::exception& e) {
96879       {
96880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96881       };
96882     } catch (Dali::DaliException e) {
96883       {
96884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96885       };
96886     } catch (...) {
96887       {
96888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96889       };
96890     }
96891   }
96892
96893 }
96894
96895
96896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96897   void * jresult ;
96898   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96899
96900   {
96901     try {
96902       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96903     } catch (std::out_of_range& e) {
96904       {
96905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96906       };
96907     } catch (std::exception& e) {
96908       {
96909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96910       };
96911     } catch (Dali::DaliException e) {
96912       {
96913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96914       };
96915     } catch (...) {
96916       {
96917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96918       };
96919     }
96920   }
96921
96922   jresult = (void *)result;
96923   return jresult;
96924 }
96925
96926
96927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96928   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96929
96930   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96931   {
96932     try {
96933       delete arg1;
96934     } catch (std::out_of_range& e) {
96935       {
96936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96937       };
96938     } catch (std::exception& e) {
96939       {
96940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96941       };
96942     } catch (Dali::DaliException e) {
96943       {
96944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96945       };
96946     } catch (...) {
96947       {
96948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96949       };
96950     }
96951   }
96952
96953 }
96954
96955
96956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96957   unsigned int jresult ;
96958   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96959   bool result;
96960
96961   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96962   {
96963     try {
96964       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);
96965     } catch (std::out_of_range& e) {
96966       {
96967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96968       };
96969     } catch (std::exception& e) {
96970       {
96971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96972       };
96973     } catch (Dali::DaliException e) {
96974       {
96975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96976       };
96977     } catch (...) {
96978       {
96979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96980       };
96981     }
96982   }
96983
96984   jresult = result;
96985   return jresult;
96986 }
96987
96988
96989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96990   unsigned long jresult ;
96991   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96992   std::size_t result;
96993
96994   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96995   {
96996     try {
96997       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);
96998     } catch (std::out_of_range& e) {
96999       {
97000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97001       };
97002     } catch (std::exception& e) {
97003       {
97004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97005       };
97006     } catch (Dali::DaliException e) {
97007       {
97008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97009       };
97010     } catch (...) {
97011       {
97012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97013       };
97014     }
97015   }
97016
97017   jresult = (unsigned long)result;
97018   return jresult;
97019 }
97020
97021
97022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97023   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97024   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97025
97026   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97027   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97028   {
97029     try {
97030       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97031     } catch (std::out_of_range& e) {
97032       {
97033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97034       };
97035     } catch (std::exception& e) {
97036       {
97037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97038       };
97039     } catch (Dali::DaliException e) {
97040       {
97041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97042       };
97043     } catch (...) {
97044       {
97045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97046       };
97047     }
97048   }
97049
97050 }
97051
97052
97053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97054   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97055   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97056
97057   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97058   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97059   {
97060     try {
97061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97062     } catch (std::out_of_range& e) {
97063       {
97064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97065       };
97066     } catch (std::exception& e) {
97067       {
97068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97069       };
97070     } catch (Dali::DaliException e) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97073       };
97074     } catch (...) {
97075       {
97076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97077       };
97078     }
97079   }
97080
97081 }
97082
97083
97084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97085   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97086   Dali::Toolkit::PageTurnView arg2 ;
97087   unsigned int arg3 ;
97088   bool arg4 ;
97089   Dali::Toolkit::PageTurnView *argp2 ;
97090
97091   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97092   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97093   if (!argp2) {
97094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97095     return ;
97096   }
97097   arg2 = *argp2;
97098   arg3 = (unsigned int)jarg3;
97099   arg4 = jarg4 ? true : false;
97100   {
97101     try {
97102       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97103     } catch (std::out_of_range& e) {
97104       {
97105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (std::exception& e) {
97108       {
97109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97110       };
97111     } catch (Dali::DaliException e) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97114       };
97115     } catch (...) {
97116       {
97117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97118       };
97119     }
97120   }
97121
97122 }
97123
97124
97125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97126   void * jresult ;
97127   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97128
97129   {
97130     try {
97131       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97132     } catch (std::out_of_range& e) {
97133       {
97134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97135       };
97136     } catch (std::exception& e) {
97137       {
97138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97139       };
97140     } catch (Dali::DaliException e) {
97141       {
97142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97143       };
97144     } catch (...) {
97145       {
97146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97147       };
97148     }
97149   }
97150
97151   jresult = (void *)result;
97152   return jresult;
97153 }
97154
97155
97156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97157   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97158
97159   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97160   {
97161     try {
97162       delete arg1;
97163     } catch (std::out_of_range& e) {
97164       {
97165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (std::exception& e) {
97168       {
97169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97170       };
97171     } catch (Dali::DaliException e) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97174       };
97175     } catch (...) {
97176       {
97177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97178       };
97179     }
97180   }
97181
97182 }
97183
97184
97185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97186   unsigned int jresult ;
97187   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97188   bool result;
97189
97190   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97191   {
97192     try {
97193       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97194     } catch (std::out_of_range& e) {
97195       {
97196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97197       };
97198     } catch (std::exception& e) {
97199       {
97200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97201       };
97202     } catch (Dali::DaliException e) {
97203       {
97204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97205       };
97206     } catch (...) {
97207       {
97208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97209       };
97210     }
97211   }
97212
97213   jresult = result;
97214   return jresult;
97215 }
97216
97217
97218 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97219   unsigned long jresult ;
97220   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97221   std::size_t result;
97222
97223   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97224   {
97225     try {
97226       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97227     } catch (std::out_of_range& e) {
97228       {
97229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97230       };
97231     } catch (std::exception& e) {
97232       {
97233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97234       };
97235     } catch (Dali::DaliException e) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97238       };
97239     } catch (...) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97242       };
97243     }
97244   }
97245
97246   jresult = (unsigned long)result;
97247   return jresult;
97248 }
97249
97250
97251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97252   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97253   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97254
97255   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97256   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97257   {
97258     try {
97259       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97260     } catch (std::out_of_range& e) {
97261       {
97262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97263       };
97264     } catch (std::exception& e) {
97265       {
97266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97267       };
97268     } catch (Dali::DaliException e) {
97269       {
97270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97271       };
97272     } catch (...) {
97273       {
97274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97275       };
97276     }
97277   }
97278
97279 }
97280
97281
97282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97283   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97284   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97285
97286   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97287   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97288   {
97289     try {
97290       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97291     } catch (std::out_of_range& e) {
97292       {
97293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97294       };
97295     } catch (std::exception& e) {
97296       {
97297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97298       };
97299     } catch (Dali::DaliException e) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97302       };
97303     } catch (...) {
97304       {
97305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97306       };
97307     }
97308   }
97309
97310 }
97311
97312
97313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97314   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97315   Dali::Toolkit::PageTurnView arg2 ;
97316   Dali::Toolkit::PageTurnView *argp2 ;
97317
97318   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97319   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97320   if (!argp2) {
97321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97322     return ;
97323   }
97324   arg2 = *argp2;
97325   {
97326     try {
97327       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97328     } catch (std::out_of_range& e) {
97329       {
97330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97331       };
97332     } catch (std::exception& e) {
97333       {
97334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97335       };
97336     } catch (Dali::DaliException e) {
97337       {
97338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97339       };
97340     } catch (...) {
97341       {
97342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97343       };
97344     }
97345   }
97346
97347 }
97348
97349
97350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97351   void * jresult ;
97352   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97353
97354   {
97355     try {
97356       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97357     } catch (std::out_of_range& e) {
97358       {
97359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97360       };
97361     } catch (std::exception& e) {
97362       {
97363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97364       };
97365     } catch (Dali::DaliException e) {
97366       {
97367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97368       };
97369     } catch (...) {
97370       {
97371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97372       };
97373     }
97374   }
97375
97376   jresult = (void *)result;
97377   return jresult;
97378 }
97379
97380
97381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97382   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97383
97384   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97385   {
97386     try {
97387       delete arg1;
97388     } catch (std::out_of_range& e) {
97389       {
97390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97391       };
97392     } catch (std::exception& e) {
97393       {
97394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97395       };
97396     } catch (Dali::DaliException e) {
97397       {
97398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97399       };
97400     } catch (...) {
97401       {
97402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97403       };
97404     }
97405   }
97406
97407 }
97408
97409
97410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97411   unsigned int jresult ;
97412   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97413   bool result;
97414
97415   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97416   {
97417     try {
97418       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);
97419     } catch (std::out_of_range& e) {
97420       {
97421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97422       };
97423     } catch (std::exception& e) {
97424       {
97425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97426       };
97427     } catch (Dali::DaliException e) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97430       };
97431     } catch (...) {
97432       {
97433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97434       };
97435     }
97436   }
97437
97438   jresult = result;
97439   return jresult;
97440 }
97441
97442
97443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97444   unsigned long jresult ;
97445   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97446   std::size_t result;
97447
97448   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97449   {
97450     try {
97451       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);
97452     } catch (std::out_of_range& e) {
97453       {
97454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97455       };
97456     } catch (std::exception& e) {
97457       {
97458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97459       };
97460     } catch (Dali::DaliException e) {
97461       {
97462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97463       };
97464     } catch (...) {
97465       {
97466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97467       };
97468     }
97469   }
97470
97471   jresult = (unsigned long)result;
97472   return jresult;
97473 }
97474
97475
97476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97477   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97478   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97479
97480   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97481   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97482   {
97483     try {
97484       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97485     } catch (std::out_of_range& e) {
97486       {
97487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97488       };
97489     } catch (std::exception& e) {
97490       {
97491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97492       };
97493     } catch (Dali::DaliException e) {
97494       {
97495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97496       };
97497     } catch (...) {
97498       {
97499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97500       };
97501     }
97502   }
97503
97504 }
97505
97506
97507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97508   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97509   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97510
97511   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97512   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97513   {
97514     try {
97515       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97516     } catch (std::out_of_range& e) {
97517       {
97518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97519       };
97520     } catch (std::exception& e) {
97521       {
97522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97523       };
97524     } catch (Dali::DaliException e) {
97525       {
97526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97527       };
97528     } catch (...) {
97529       {
97530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97531       };
97532     }
97533   }
97534
97535 }
97536
97537
97538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97539   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97540   Dali::Toolkit::ProgressBar arg2 ;
97541   float arg3 ;
97542   float arg4 ;
97543   Dali::Toolkit::ProgressBar *argp2 ;
97544
97545   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97546   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97547   if (!argp2) {
97548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97549     return ;
97550   }
97551   arg2 = *argp2;
97552   arg3 = (float)jarg3;
97553   arg4 = (float)jarg4;
97554   {
97555     try {
97556       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97557     } catch (std::out_of_range& e) {
97558       {
97559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97560       };
97561     } catch (std::exception& e) {
97562       {
97563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97564       };
97565     } catch (Dali::DaliException e) {
97566       {
97567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97568       };
97569     } catch (...) {
97570       {
97571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97572       };
97573     }
97574   }
97575
97576 }
97577
97578
97579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97580   void * jresult ;
97581   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97582
97583   {
97584     try {
97585       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97586     } catch (std::out_of_range& e) {
97587       {
97588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97589       };
97590     } catch (std::exception& e) {
97591       {
97592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97593       };
97594     } catch (Dali::DaliException e) {
97595       {
97596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97597       };
97598     } catch (...) {
97599       {
97600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97601       };
97602     }
97603   }
97604
97605   jresult = (void *)result;
97606   return jresult;
97607 }
97608
97609
97610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97611   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97612
97613   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97614   {
97615     try {
97616       delete arg1;
97617     } catch (std::out_of_range& e) {
97618       {
97619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97620       };
97621     } catch (std::exception& e) {
97622       {
97623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97624       };
97625     } catch (Dali::DaliException e) {
97626       {
97627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97628       };
97629     } catch (...) {
97630       {
97631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97632       };
97633     }
97634   }
97635
97636 }
97637
97638
97639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97640   unsigned int jresult ;
97641   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97642   bool result;
97643
97644   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97645   {
97646     try {
97647       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);
97648     } catch (std::out_of_range& e) {
97649       {
97650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97651       };
97652     } catch (std::exception& e) {
97653       {
97654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97655       };
97656     } catch (Dali::DaliException e) {
97657       {
97658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97659       };
97660     } catch (...) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97663       };
97664     }
97665   }
97666
97667   jresult = result;
97668   return jresult;
97669 }
97670
97671
97672 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97673   unsigned long jresult ;
97674   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97675   std::size_t result;
97676
97677   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97678   {
97679     try {
97680       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);
97681     } catch (std::out_of_range& e) {
97682       {
97683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97684       };
97685     } catch (std::exception& e) {
97686       {
97687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97688       };
97689     } catch (Dali::DaliException e) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97692       };
97693     } catch (...) {
97694       {
97695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97696       };
97697     }
97698   }
97699
97700   jresult = (unsigned long)result;
97701   return jresult;
97702 }
97703
97704
97705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97706   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97707   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97708
97709   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97710   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97711   {
97712     try {
97713       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97714     } catch (std::out_of_range& e) {
97715       {
97716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97717       };
97718     } catch (std::exception& e) {
97719       {
97720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97721       };
97722     } catch (Dali::DaliException e) {
97723       {
97724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97725       };
97726     } catch (...) {
97727       {
97728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97729       };
97730     }
97731   }
97732
97733 }
97734
97735
97736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97737   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97738   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97739
97740   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97741   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97742   {
97743     try {
97744       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97745     } catch (std::out_of_range& e) {
97746       {
97747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97748       };
97749     } catch (std::exception& e) {
97750       {
97751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97752       };
97753     } catch (Dali::DaliException e) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97756       };
97757     } catch (...) {
97758       {
97759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97760       };
97761     }
97762   }
97763
97764 }
97765
97766
97767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97768   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97769   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97770
97771   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97772   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97773   if (!arg2) {
97774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97775     return ;
97776   }
97777   {
97778     try {
97779       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97780     } catch (std::out_of_range& e) {
97781       {
97782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97783       };
97784     } catch (std::exception& e) {
97785       {
97786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97787       };
97788     } catch (Dali::DaliException e) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97791       };
97792     } catch (...) {
97793       {
97794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97795       };
97796     }
97797   }
97798
97799 }
97800
97801
97802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97803   void * jresult ;
97804   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97805
97806   {
97807     try {
97808       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97809     } catch (std::out_of_range& e) {
97810       {
97811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97812       };
97813     } catch (std::exception& e) {
97814       {
97815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97816       };
97817     } catch (Dali::DaliException e) {
97818       {
97819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97820       };
97821     } catch (...) {
97822       {
97823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97824       };
97825     }
97826   }
97827
97828   jresult = (void *)result;
97829   return jresult;
97830 }
97831
97832
97833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97834   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97835
97836   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97837   {
97838     try {
97839       delete arg1;
97840     } catch (std::out_of_range& e) {
97841       {
97842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97843       };
97844     } catch (std::exception& e) {
97845       {
97846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97847       };
97848     } catch (Dali::DaliException e) {
97849       {
97850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97851       };
97852     } catch (...) {
97853       {
97854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97855       };
97856     }
97857   }
97858
97859 }
97860
97861
97862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97863   unsigned int jresult ;
97864   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97865   bool result;
97866
97867   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97868   {
97869     try {
97870       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97871     } catch (std::out_of_range& e) {
97872       {
97873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97874       };
97875     } catch (std::exception& e) {
97876       {
97877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97878       };
97879     } catch (Dali::DaliException e) {
97880       {
97881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97882       };
97883     } catch (...) {
97884       {
97885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97886       };
97887     }
97888   }
97889
97890   jresult = result;
97891   return jresult;
97892 }
97893
97894
97895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97896   unsigned long jresult ;
97897   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97898   std::size_t result;
97899
97900   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97901   {
97902     try {
97903       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97904     } catch (std::out_of_range& e) {
97905       {
97906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97907       };
97908     } catch (std::exception& e) {
97909       {
97910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97911       };
97912     } catch (Dali::DaliException e) {
97913       {
97914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97915       };
97916     } catch (...) {
97917       {
97918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97919       };
97920     }
97921   }
97922
97923   jresult = (unsigned long)result;
97924   return jresult;
97925 }
97926
97927
97928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97929   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97930   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97931
97932   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97933   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97934   {
97935     try {
97936       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97937     } catch (std::out_of_range& e) {
97938       {
97939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97940       };
97941     } catch (std::exception& e) {
97942       {
97943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97944       };
97945     } catch (Dali::DaliException e) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97948       };
97949     } catch (...) {
97950       {
97951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97952       };
97953     }
97954   }
97955
97956 }
97957
97958
97959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97960   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97961   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97962
97963   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97964   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97965   {
97966     try {
97967       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97968     } catch (std::out_of_range& e) {
97969       {
97970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97971       };
97972     } catch (std::exception& e) {
97973       {
97974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97975       };
97976     } catch (Dali::DaliException e) {
97977       {
97978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97979       };
97980     } catch (...) {
97981       {
97982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97983       };
97984     }
97985   }
97986
97987 }
97988
97989
97990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97991   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97992   Dali::Vector2 *arg2 = 0 ;
97993
97994   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97995   arg2 = (Dali::Vector2 *)jarg2;
97996   if (!arg2) {
97997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97998     return ;
97999   }
98000   {
98001     try {
98002       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98003     } catch (std::out_of_range& e) {
98004       {
98005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98006       };
98007     } catch (std::exception& e) {
98008       {
98009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98010       };
98011     } catch (Dali::DaliException e) {
98012       {
98013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98014       };
98015     } catch (...) {
98016       {
98017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98018       };
98019     }
98020   }
98021
98022 }
98023
98024
98025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98026   void * jresult ;
98027   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98028
98029   {
98030     try {
98031       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98032     } catch (std::out_of_range& e) {
98033       {
98034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98035       };
98036     } catch (std::exception& e) {
98037       {
98038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98039       };
98040     } catch (Dali::DaliException e) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98043       };
98044     } catch (...) {
98045       {
98046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98047       };
98048     }
98049   }
98050
98051   jresult = (void *)result;
98052   return jresult;
98053 }
98054
98055
98056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98057   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98058
98059   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98060   {
98061     try {
98062       delete arg1;
98063     } catch (std::out_of_range& e) {
98064       {
98065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98066       };
98067     } catch (std::exception& e) {
98068       {
98069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98070       };
98071     } catch (Dali::DaliException e) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98074       };
98075     } catch (...) {
98076       {
98077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98078       };
98079     }
98080   }
98081
98082 }
98083
98084
98085
98086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98087   unsigned int jresult ;
98088   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98089   bool result;
98090
98091   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98092   {
98093     try {
98094       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);
98095     } catch (std::out_of_range& e) {
98096       {
98097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98098       };
98099     } catch (std::exception& e) {
98100       {
98101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98102       };
98103     } catch (Dali::DaliException e) {
98104       {
98105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98106       };
98107     } catch (...) {
98108       {
98109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98110       };
98111     }
98112   }
98113
98114   jresult = result;
98115   return jresult;
98116 }
98117
98118
98119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98120   unsigned long jresult ;
98121   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98122   std::size_t result;
98123
98124   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98125   {
98126     try {
98127       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);
98128     } catch (std::out_of_range& e) {
98129       {
98130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98131       };
98132     } catch (std::exception& e) {
98133       {
98134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98135       };
98136     } catch (Dali::DaliException e) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98139       };
98140     } catch (...) {
98141       {
98142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98143       };
98144     }
98145   }
98146
98147   jresult = (unsigned long)result;
98148   return jresult;
98149 }
98150
98151
98152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98153   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98154   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98155
98156   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98157   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98158   {
98159     try {
98160       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98161     } catch (std::out_of_range& e) {
98162       {
98163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98164       };
98165     } catch (std::exception& e) {
98166       {
98167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98168       };
98169     } catch (Dali::DaliException e) {
98170       {
98171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98172       };
98173     } catch (...) {
98174       {
98175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98176       };
98177     }
98178   }
98179
98180 }
98181
98182
98183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98184   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98185   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98186
98187   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98188   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98189   {
98190     try {
98191       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98192     } catch (std::out_of_range& e) {
98193       {
98194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98195       };
98196     } catch (std::exception& e) {
98197       {
98198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98199       };
98200     } catch (Dali::DaliException e) {
98201       {
98202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98203       };
98204     } catch (...) {
98205       {
98206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98207       };
98208     }
98209   }
98210
98211 }
98212
98213
98214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98215   unsigned int jresult ;
98216   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98217   Dali::Toolkit::Control arg2 ;
98218   Dali::KeyEvent *arg3 = 0 ;
98219   Dali::Toolkit::Control *argp2 ;
98220   bool result;
98221
98222   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98223   argp2 = (Dali::Toolkit::Control *)jarg2;
98224   if (!argp2) {
98225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98226     return 0;
98227   }
98228   arg2 = *argp2;
98229   arg3 = (Dali::KeyEvent *)jarg3;
98230   if (!arg3) {
98231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98232     return 0;
98233   }
98234   {
98235     try {
98236       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);
98237     } catch (std::out_of_range& e) {
98238       {
98239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98240       };
98241     } catch (std::exception& e) {
98242       {
98243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98244       };
98245     } catch (Dali::DaliException e) {
98246       {
98247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98248       };
98249     } catch (...) {
98250       {
98251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98252       };
98253     }
98254   }
98255
98256   jresult = result;
98257   return jresult;
98258 }
98259
98260
98261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98262   void * jresult ;
98263   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98264
98265   {
98266     try {
98267       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98268     } catch (std::out_of_range& e) {
98269       {
98270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98271       };
98272     } catch (std::exception& e) {
98273       {
98274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98275       };
98276     } catch (Dali::DaliException e) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98279       };
98280     } catch (...) {
98281       {
98282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98283       };
98284     }
98285   }
98286
98287   jresult = (void *)result;
98288   return jresult;
98289 }
98290
98291
98292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98293   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98294
98295   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98296   {
98297     try {
98298       delete arg1;
98299     } catch (std::out_of_range& e) {
98300       {
98301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98302       };
98303     } catch (std::exception& e) {
98304       {
98305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98306       };
98307     } catch (Dali::DaliException e) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98310       };
98311     } catch (...) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98314       };
98315     }
98316   }
98317
98318 }
98319
98320
98321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98322   unsigned int jresult ;
98323   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98324   bool result;
98325
98326   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98327   {
98328     try {
98329       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98330     } catch (std::out_of_range& e) {
98331       {
98332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98333       };
98334     } catch (std::exception& e) {
98335       {
98336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98337       };
98338     } catch (Dali::DaliException e) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98341       };
98342     } catch (...) {
98343       {
98344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98345       };
98346     }
98347   }
98348
98349   jresult = result;
98350   return jresult;
98351 }
98352
98353
98354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98355   unsigned long jresult ;
98356   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98357   std::size_t result;
98358
98359   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98360   {
98361     try {
98362       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98363     } catch (std::out_of_range& e) {
98364       {
98365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98366       };
98367     } catch (std::exception& e) {
98368       {
98369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98370       };
98371     } catch (Dali::DaliException e) {
98372       {
98373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98374       };
98375     } catch (...) {
98376       {
98377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98378       };
98379     }
98380   }
98381
98382   jresult = (unsigned long)result;
98383   return jresult;
98384 }
98385
98386
98387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98388   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98389   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98390
98391   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98392   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98393   {
98394     try {
98395       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98396     } catch (std::out_of_range& e) {
98397       {
98398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98399       };
98400     } catch (std::exception& e) {
98401       {
98402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98403       };
98404     } catch (Dali::DaliException e) {
98405       {
98406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98407       };
98408     } catch (...) {
98409       {
98410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98411       };
98412     }
98413   }
98414
98415 }
98416
98417
98418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98419   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98420   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98421
98422   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98423   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98424   {
98425     try {
98426       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98427     } catch (std::out_of_range& e) {
98428       {
98429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98430       };
98431     } catch (std::exception& e) {
98432       {
98433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98434       };
98435     } catch (Dali::DaliException e) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98438       };
98439     } catch (...) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98442       };
98443     }
98444   }
98445
98446 }
98447
98448
98449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98450   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98451   Dali::Toolkit::Control arg2 ;
98452   Dali::Toolkit::Control *argp2 ;
98453
98454   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98455   argp2 = (Dali::Toolkit::Control *)jarg2;
98456   if (!argp2) {
98457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98458     return ;
98459   }
98460   arg2 = *argp2;
98461   {
98462     try {
98463       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98464     } catch (std::out_of_range& e) {
98465       {
98466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (std::exception& e) {
98469       {
98470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (Dali::DaliException e) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98475       };
98476     } catch (...) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98479       };
98480     }
98481   }
98482
98483 }
98484
98485
98486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98487   void * jresult ;
98488   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98489
98490   {
98491     try {
98492       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98493     } catch (std::out_of_range& e) {
98494       {
98495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98496       };
98497     } catch (std::exception& e) {
98498       {
98499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98500       };
98501     } catch (Dali::DaliException e) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98504       };
98505     } catch (...) {
98506       {
98507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98508       };
98509     }
98510   }
98511
98512   jresult = (void *)result;
98513   return jresult;
98514 }
98515
98516
98517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98518   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98519
98520   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98521   {
98522     try {
98523       delete arg1;
98524     } catch (std::out_of_range& e) {
98525       {
98526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (std::exception& e) {
98529       {
98530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98531       };
98532     } catch (Dali::DaliException e) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98535       };
98536     } catch (...) {
98537       {
98538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98539       };
98540     }
98541   }
98542
98543 }
98544
98545
98546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98547   unsigned int jresult ;
98548   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98549   bool result;
98550
98551   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98552   {
98553     try {
98554       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98555     } catch (std::out_of_range& e) {
98556       {
98557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98558       };
98559     } catch (std::exception& e) {
98560       {
98561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98562       };
98563     } catch (Dali::DaliException e) {
98564       {
98565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98566       };
98567     } catch (...) {
98568       {
98569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98570       };
98571     }
98572   }
98573
98574   jresult = result;
98575   return jresult;
98576 }
98577
98578
98579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98580   unsigned long jresult ;
98581   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98582   std::size_t result;
98583
98584   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98585   {
98586     try {
98587       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98588     } catch (std::out_of_range& e) {
98589       {
98590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98591       };
98592     } catch (std::exception& e) {
98593       {
98594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98595       };
98596     } catch (Dali::DaliException e) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98599       };
98600     } catch (...) {
98601       {
98602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98603       };
98604     }
98605   }
98606
98607   jresult = (unsigned long)result;
98608   return jresult;
98609 }
98610
98611
98612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98613   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98614   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98615
98616   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98617   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98618   {
98619     try {
98620       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98621     } catch (std::out_of_range& e) {
98622       {
98623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98624       };
98625     } catch (std::exception& e) {
98626       {
98627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98628       };
98629     } catch (Dali::DaliException e) {
98630       {
98631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98632       };
98633     } catch (...) {
98634       {
98635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98636       };
98637     }
98638   }
98639
98640 }
98641
98642
98643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98644   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98645   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98646
98647   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98648   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98649   {
98650     try {
98651       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98652     } catch (std::out_of_range& e) {
98653       {
98654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98655       };
98656     } catch (std::exception& e) {
98657       {
98658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98659       };
98660     } catch (Dali::DaliException e) {
98661       {
98662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98663       };
98664     } catch (...) {
98665       {
98666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98667       };
98668     }
98669   }
98670
98671 }
98672
98673
98674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98675   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98676   Dali::Toolkit::VideoView *arg2 = 0 ;
98677
98678   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98679   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98680   if (!arg2) {
98681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98682     return ;
98683   }
98684   {
98685     try {
98686       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98687     } catch (std::out_of_range& e) {
98688       {
98689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98690       };
98691     } catch (std::exception& e) {
98692       {
98693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98694       };
98695     } catch (Dali::DaliException e) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98698       };
98699     } catch (...) {
98700       {
98701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98702       };
98703     }
98704   }
98705
98706 }
98707
98708
98709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98710   void * jresult ;
98711   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98712
98713   {
98714     try {
98715       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98716     } catch (std::out_of_range& e) {
98717       {
98718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98719       };
98720     } catch (std::exception& e) {
98721       {
98722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98723       };
98724     } catch (Dali::DaliException e) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98727       };
98728     } catch (...) {
98729       {
98730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98731       };
98732     }
98733   }
98734
98735   jresult = (void *)result;
98736   return jresult;
98737 }
98738
98739
98740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98741   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98742
98743   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98744   {
98745     try {
98746       delete arg1;
98747     } catch (std::out_of_range& e) {
98748       {
98749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98750       };
98751     } catch (std::exception& e) {
98752       {
98753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98754       };
98755     } catch (Dali::DaliException e) {
98756       {
98757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98758       };
98759     } catch (...) {
98760       {
98761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98762       };
98763     }
98764   }
98765
98766 }
98767
98768
98769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98770   unsigned int jresult ;
98771   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98772   bool result;
98773
98774   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98775   {
98776     try {
98777       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98778     } catch (std::out_of_range& e) {
98779       {
98780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98781       };
98782     } catch (std::exception& e) {
98783       {
98784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (Dali::DaliException e) {
98787       {
98788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98793       };
98794     }
98795   }
98796
98797   jresult = result;
98798   return jresult;
98799 }
98800
98801
98802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98803   unsigned long jresult ;
98804   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98805   std::size_t result;
98806
98807   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98808   {
98809     try {
98810       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98811     } catch (std::out_of_range& e) {
98812       {
98813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98814       };
98815     } catch (std::exception& e) {
98816       {
98817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98818       };
98819     } catch (Dali::DaliException e) {
98820       {
98821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98822       };
98823     } catch (...) {
98824       {
98825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98826       };
98827     }
98828   }
98829
98830   jresult = (unsigned long)result;
98831   return jresult;
98832 }
98833
98834
98835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98836   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98837   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98838
98839   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98840   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98841   {
98842     try {
98843       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98844     } catch (std::out_of_range& e) {
98845       {
98846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98847       };
98848     } catch (std::exception& e) {
98849       {
98850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98851       };
98852     } catch (Dali::DaliException e) {
98853       {
98854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98855       };
98856     } catch (...) {
98857       {
98858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98859       };
98860     }
98861   }
98862
98863 }
98864
98865
98866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98867   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98868   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98869
98870   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98871   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98872   {
98873     try {
98874       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98875     } catch (std::out_of_range& e) {
98876       {
98877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98878       };
98879     } catch (std::exception& e) {
98880       {
98881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98882       };
98883     } catch (Dali::DaliException e) {
98884       {
98885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98886       };
98887     } catch (...) {
98888       {
98889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98890       };
98891     }
98892   }
98893
98894 }
98895
98896
98897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98898   unsigned int jresult ;
98899   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98900   Dali::Toolkit::Slider arg2 ;
98901   float arg3 ;
98902   Dali::Toolkit::Slider *argp2 ;
98903   bool result;
98904
98905   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98906   argp2 = (Dali::Toolkit::Slider *)jarg2;
98907   if (!argp2) {
98908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98909     return 0;
98910   }
98911   arg2 = *argp2;
98912   arg3 = (float)jarg3;
98913   {
98914     try {
98915       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98916     } catch (std::out_of_range& e) {
98917       {
98918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98919       };
98920     } catch (std::exception& e) {
98921       {
98922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98923       };
98924     } catch (Dali::DaliException e) {
98925       {
98926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98927       };
98928     } catch (...) {
98929       {
98930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98931       };
98932     }
98933   }
98934
98935   jresult = result;
98936   return jresult;
98937 }
98938
98939
98940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98941   void * jresult ;
98942   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98943
98944   {
98945     try {
98946       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98947     } catch (std::out_of_range& e) {
98948       {
98949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98950       };
98951     } catch (std::exception& e) {
98952       {
98953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98954       };
98955     } catch (Dali::DaliException e) {
98956       {
98957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98958       };
98959     } catch (...) {
98960       {
98961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98962       };
98963     }
98964   }
98965
98966   jresult = (void *)result;
98967   return jresult;
98968 }
98969
98970
98971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98972   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98973
98974   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98975   {
98976     try {
98977       delete arg1;
98978     } catch (std::out_of_range& e) {
98979       {
98980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98981       };
98982     } catch (std::exception& e) {
98983       {
98984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98985       };
98986     } catch (Dali::DaliException e) {
98987       {
98988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98989       };
98990     } catch (...) {
98991       {
98992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98993       };
98994     }
98995   }
98996
98997 }
98998
98999
99000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99001   unsigned int jresult ;
99002   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99003   bool result;
99004
99005   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99006   {
99007     try {
99008       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99009     } catch (std::out_of_range& e) {
99010       {
99011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (std::exception& e) {
99014       {
99015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99016       };
99017     } catch (Dali::DaliException e) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99020       };
99021     } catch (...) {
99022       {
99023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99024       };
99025     }
99026   }
99027
99028   jresult = result;
99029   return jresult;
99030 }
99031
99032
99033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99034   unsigned long jresult ;
99035   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99036   std::size_t result;
99037
99038   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99039   {
99040     try {
99041       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99042     } catch (std::out_of_range& e) {
99043       {
99044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99045       };
99046     } catch (std::exception& e) {
99047       {
99048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99049       };
99050     } catch (Dali::DaliException e) {
99051       {
99052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99053       };
99054     } catch (...) {
99055       {
99056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99057       };
99058     }
99059   }
99060
99061   jresult = (unsigned long)result;
99062   return jresult;
99063 }
99064
99065
99066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99067   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99068   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99069
99070   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99071   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99072   {
99073     try {
99074       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99075     } catch (std::out_of_range& e) {
99076       {
99077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99078       };
99079     } catch (std::exception& e) {
99080       {
99081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99082       };
99083     } catch (Dali::DaliException e) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99086       };
99087     } catch (...) {
99088       {
99089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99090       };
99091     }
99092   }
99093
99094 }
99095
99096
99097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99098   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99099   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99100
99101   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99102   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99103   {
99104     try {
99105       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99106     } catch (std::out_of_range& e) {
99107       {
99108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99109       };
99110     } catch (std::exception& e) {
99111       {
99112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99113       };
99114     } catch (Dali::DaliException e) {
99115       {
99116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99117       };
99118     } catch (...) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99121       };
99122     }
99123   }
99124
99125 }
99126
99127
99128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99129   unsigned int jresult ;
99130   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99131   Dali::Toolkit::Slider arg2 ;
99132   int arg3 ;
99133   Dali::Toolkit::Slider *argp2 ;
99134   bool result;
99135
99136   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99137   argp2 = (Dali::Toolkit::Slider *)jarg2;
99138   if (!argp2) {
99139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99140     return 0;
99141   }
99142   arg2 = *argp2;
99143   arg3 = (int)jarg3;
99144   {
99145     try {
99146       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99147     } catch (std::out_of_range& e) {
99148       {
99149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99150       };
99151     } catch (std::exception& e) {
99152       {
99153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99154       };
99155     } catch (Dali::DaliException e) {
99156       {
99157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99158       };
99159     } catch (...) {
99160       {
99161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99162       };
99163     }
99164   }
99165
99166   jresult = result;
99167   return jresult;
99168 }
99169
99170
99171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99172   void * jresult ;
99173   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99174
99175   {
99176     try {
99177       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99178     } catch (std::out_of_range& e) {
99179       {
99180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99181       };
99182     } catch (std::exception& e) {
99183       {
99184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99185       };
99186     } catch (Dali::DaliException e) {
99187       {
99188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99189       };
99190     } catch (...) {
99191       {
99192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99193       };
99194     }
99195   }
99196
99197   jresult = (void *)result;
99198   return jresult;
99199 }
99200
99201
99202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99203   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99204
99205   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99206   {
99207     try {
99208       delete arg1;
99209     } catch (std::out_of_range& e) {
99210       {
99211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99212       };
99213     } catch (std::exception& e) {
99214       {
99215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99216       };
99217     } catch (Dali::DaliException e) {
99218       {
99219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99220       };
99221     } catch (...) {
99222       {
99223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99224       };
99225     }
99226   }
99227
99228 }
99229
99230
99231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99232   void * jresult ;
99233   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99234
99235   {
99236     try {
99237       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99238     } catch (std::out_of_range& e) {
99239       {
99240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99241       };
99242     } catch (std::exception& e) {
99243       {
99244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99245       };
99246     } catch (Dali::DaliException e) {
99247       {
99248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99249       };
99250     } catch (...) {
99251       {
99252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99253       };
99254     }
99255   }
99256
99257   jresult = (void *)result;
99258   return jresult;
99259 }
99260
99261
99262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99263   void * jresult ;
99264   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99265   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99266
99267   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99268   {
99269     try {
99270       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99271     } catch (std::out_of_range& e) {
99272       {
99273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99274       };
99275     } catch (std::exception& e) {
99276       {
99277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99278       };
99279     } catch (Dali::DaliException e) {
99280       {
99281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99282       };
99283     } catch (...) {
99284       {
99285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99286       };
99287     }
99288   }
99289
99290   jresult = (void *)result;
99291   return jresult;
99292 }
99293
99294
99295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99296   void * jresult ;
99297   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99299
99300   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99301   if (!arg1) {
99302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99303     return 0;
99304   }
99305   {
99306     try {
99307       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99308     } catch (std::out_of_range& e) {
99309       {
99310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99311       };
99312     } catch (std::exception& e) {
99313       {
99314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99315       };
99316     } catch (Dali::DaliException e) {
99317       {
99318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99319       };
99320     } catch (...) {
99321       {
99322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99323       };
99324     }
99325   }
99326
99327   jresult = (void *)result;
99328   return jresult;
99329 }
99330
99331
99332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99333   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99334
99335   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99336   {
99337     try {
99338       delete arg1;
99339     } catch (std::out_of_range& e) {
99340       {
99341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99342       };
99343     } catch (std::exception& e) {
99344       {
99345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99346       };
99347     } catch (Dali::DaliException e) {
99348       {
99349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99350       };
99351     } catch (...) {
99352       {
99353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99354       };
99355     }
99356   }
99357
99358 }
99359
99360
99361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99362   void * jresult ;
99363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99364   Dali::Toolkit::Ruler *result = 0 ;
99365
99366   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99367   {
99368     try {
99369       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99370     } catch (std::out_of_range& e) {
99371       {
99372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99373       };
99374     } catch (std::exception& e) {
99375       {
99376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99377       };
99378     } catch (Dali::DaliException e) {
99379       {
99380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99381       };
99382     } catch (...) {
99383       {
99384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99385       };
99386     }
99387   }
99388
99389   jresult = (void *)result;
99390   return jresult;
99391 }
99392
99393
99394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99395   void * jresult ;
99396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99397   Dali::Toolkit::Ruler *result = 0 ;
99398
99399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99400   {
99401     try {
99402       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99403     } catch (std::out_of_range& e) {
99404       {
99405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99406       };
99407     } catch (std::exception& e) {
99408       {
99409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99410       };
99411     } catch (Dali::DaliException e) {
99412       {
99413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99414       };
99415     } catch (...) {
99416       {
99417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99418       };
99419     }
99420   }
99421
99422   jresult = (void *)result;
99423   return jresult;
99424 }
99425
99426
99427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99428   void * jresult ;
99429   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99430   Dali::Toolkit::Ruler *result = 0 ;
99431
99432   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99433   {
99434     try {
99435       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99436     } catch (std::out_of_range& e) {
99437       {
99438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99439       };
99440     } catch (std::exception& e) {
99441       {
99442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99443       };
99444     } catch (Dali::DaliException e) {
99445       {
99446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99447       };
99448     } catch (...) {
99449       {
99450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99451       };
99452     }
99453   }
99454
99455   jresult = (void *)result;
99456   return jresult;
99457 }
99458
99459
99460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99461   void * jresult ;
99462   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99463   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99464   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99465
99466   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99467   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99468   if (!arg2) {
99469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99470     return 0;
99471   }
99472   {
99473     try {
99474       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99475     } catch (std::out_of_range& e) {
99476       {
99477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99478       };
99479     } catch (std::exception& e) {
99480       {
99481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99482       };
99483     } catch (Dali::DaliException e) {
99484       {
99485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99486       };
99487     } catch (...) {
99488       {
99489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99490       };
99491     }
99492   }
99493
99494   jresult = (void *)result;
99495   return jresult;
99496 }
99497
99498
99499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99500   void * jresult ;
99501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99502   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99503   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99504
99505   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99506   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99507   {
99508     try {
99509       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99510     } catch (std::out_of_range& e) {
99511       {
99512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99513       };
99514     } catch (std::exception& e) {
99515       {
99516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99517       };
99518     } catch (Dali::DaliException e) {
99519       {
99520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99521       };
99522     } catch (...) {
99523       {
99524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99525       };
99526     }
99527   }
99528
99529   jresult = (void *)result;
99530   return jresult;
99531 }
99532
99533
99534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99535   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99536
99537   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99538   {
99539     try {
99540       (arg1)->Reset();
99541     } catch (std::out_of_range& e) {
99542       {
99543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99544       };
99545     } catch (std::exception& e) {
99546       {
99547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99548       };
99549     } catch (Dali::DaliException e) {
99550       {
99551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99552       };
99553     } catch (...) {
99554       {
99555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99556       };
99557     }
99558   }
99559
99560 }
99561
99562
99563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99564   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99565   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99566
99567   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99568   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99569   {
99570     try {
99571       (arg1)->Reset(arg2);
99572     } catch (std::out_of_range& e) {
99573       {
99574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99575       };
99576     } catch (std::exception& e) {
99577       {
99578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99579       };
99580     } catch (Dali::DaliException e) {
99581       {
99582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99583       };
99584     } catch (...) {
99585       {
99586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99587       };
99588     }
99589   }
99590
99591 }
99592
99593
99594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99595   void * jresult ;
99596   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99597   Dali::Toolkit::Ruler *result = 0 ;
99598
99599   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99600   {
99601     try {
99602       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99603     } catch (std::out_of_range& e) {
99604       {
99605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99606       };
99607     } catch (std::exception& e) {
99608       {
99609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99610       };
99611     } catch (Dali::DaliException e) {
99612       {
99613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99614       };
99615     } catch (...) {
99616       {
99617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99618       };
99619     }
99620   }
99621
99622   jresult = (void *)result;
99623   return jresult;
99624 }
99625
99626
99627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99628   float jresult ;
99629   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99630   float arg2 ;
99631   float arg3 ;
99632   float result;
99633
99634   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99635   arg2 = (float)jarg2;
99636   arg3 = (float)jarg3;
99637   {
99638     try {
99639       result = (float)(*arg1)->Snap(arg2,arg3);
99640     } catch (std::out_of_range& e) {
99641       {
99642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99643       };
99644     } catch (std::exception& e) {
99645       {
99646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99647       };
99648     } catch (Dali::DaliException e) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99651       };
99652     } catch (...) {
99653       {
99654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99655       };
99656     }
99657   }
99658
99659   jresult = result;
99660   return jresult;
99661 }
99662
99663
99664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99665   float jresult ;
99666   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99667   float arg2 ;
99668   float result;
99669
99670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99671   arg2 = (float)jarg2;
99672   {
99673     try {
99674       result = (float)(*arg1)->Snap(arg2);
99675     } catch (std::out_of_range& e) {
99676       {
99677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99678       };
99679     } catch (std::exception& e) {
99680       {
99681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99682       };
99683     } catch (Dali::DaliException e) {
99684       {
99685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99686       };
99687     } catch (...) {
99688       {
99689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99690       };
99691     }
99692   }
99693
99694   jresult = result;
99695   return jresult;
99696 }
99697
99698
99699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99700   float jresult ;
99701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99702   unsigned int arg2 ;
99703   unsigned int *arg3 = 0 ;
99704   bool arg4 ;
99705   float result;
99706
99707   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99708   arg2 = (unsigned int)jarg2;
99709   arg3 = (unsigned int *)jarg3;
99710   arg4 = jarg4 ? true : false;
99711   {
99712     try {
99713       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99714     } catch (std::out_of_range& e) {
99715       {
99716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99717       };
99718     } catch (std::exception& e) {
99719       {
99720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99721       };
99722     } catch (Dali::DaliException e) {
99723       {
99724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99725       };
99726     } catch (...) {
99727       {
99728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99729       };
99730     }
99731   }
99732
99733   jresult = result;
99734   return jresult;
99735 }
99736
99737
99738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99739   unsigned int jresult ;
99740   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99741   float arg2 ;
99742   bool arg3 ;
99743   unsigned int result;
99744
99745   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99746   arg2 = (float)jarg2;
99747   arg3 = jarg3 ? true : false;
99748   {
99749     try {
99750       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99751     } catch (std::out_of_range& e) {
99752       {
99753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99754       };
99755     } catch (std::exception& e) {
99756       {
99757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99758       };
99759     } catch (Dali::DaliException e) {
99760       {
99761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99762       };
99763     } catch (...) {
99764       {
99765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99766       };
99767     }
99768   }
99769
99770   jresult = result;
99771   return jresult;
99772 }
99773
99774
99775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99776   unsigned int jresult ;
99777   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99778   unsigned int result;
99779
99780   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99781   {
99782     try {
99783       result = (unsigned int)(*arg1)->GetTotalPages();
99784     } catch (std::out_of_range& e) {
99785       {
99786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99787       };
99788     } catch (std::exception& e) {
99789       {
99790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99791       };
99792     } catch (Dali::DaliException e) {
99793       {
99794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99795       };
99796     } catch (...) {
99797       {
99798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99799       };
99800     }
99801   }
99802
99803   jresult = result;
99804   return jresult;
99805 }
99806
99807
99808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99809   int jresult ;
99810   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99811   Dali::Toolkit::Ruler::RulerType result;
99812
99813   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99814   {
99815     try {
99816       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99817     } catch (std::out_of_range& e) {
99818       {
99819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99820       };
99821     } catch (std::exception& e) {
99822       {
99823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99824       };
99825     } catch (Dali::DaliException e) {
99826       {
99827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99828       };
99829     } catch (...) {
99830       {
99831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99832       };
99833     }
99834   }
99835
99836   jresult = (int)result;
99837   return jresult;
99838 }
99839
99840
99841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99842   unsigned int jresult ;
99843   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99844   bool result;
99845
99846   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99847   {
99848     try {
99849       result = (bool)(*arg1)->IsEnabled();
99850     } catch (std::out_of_range& e) {
99851       {
99852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99853       };
99854     } catch (std::exception& e) {
99855       {
99856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99857       };
99858     } catch (Dali::DaliException e) {
99859       {
99860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99861       };
99862     } catch (...) {
99863       {
99864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99865       };
99866     }
99867   }
99868
99869   jresult = result;
99870   return jresult;
99871 }
99872
99873
99874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99875   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99876
99877   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99878   {
99879     try {
99880       (*arg1)->Enable();
99881     } catch (std::out_of_range& e) {
99882       {
99883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99884       };
99885     } catch (std::exception& e) {
99886       {
99887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99888       };
99889     } catch (Dali::DaliException e) {
99890       {
99891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99892       };
99893     } catch (...) {
99894       {
99895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99896       };
99897     }
99898   }
99899
99900 }
99901
99902
99903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99905
99906   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99907   {
99908     try {
99909       (*arg1)->Disable();
99910     } catch (std::out_of_range& e) {
99911       {
99912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99913       };
99914     } catch (std::exception& e) {
99915       {
99916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99917       };
99918     } catch (Dali::DaliException e) {
99919       {
99920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99921       };
99922     } catch (...) {
99923       {
99924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99925       };
99926     }
99927   }
99928
99929 }
99930
99931
99932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99934   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99935   Dali::Toolkit::RulerDomain *argp2 ;
99936
99937   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99938   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99939   if (!argp2) {
99940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99941     return ;
99942   }
99943   arg2 = *argp2;
99944   {
99945     try {
99946       (*arg1)->SetDomain(arg2);
99947     } catch (std::out_of_range& e) {
99948       {
99949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99950       };
99951     } catch (std::exception& e) {
99952       {
99953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99954       };
99955     } catch (Dali::DaliException e) {
99956       {
99957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99958       };
99959     } catch (...) {
99960       {
99961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99962       };
99963     }
99964   }
99965
99966 }
99967
99968
99969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99970   void * jresult ;
99971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99972   Dali::Toolkit::RulerDomain *result = 0 ;
99973
99974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99975   {
99976     try {
99977       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99978     } catch (std::out_of_range& e) {
99979       {
99980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99981       };
99982     } catch (std::exception& e) {
99983       {
99984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99985       };
99986     } catch (Dali::DaliException e) {
99987       {
99988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99989       };
99990     } catch (...) {
99991       {
99992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99993       };
99994     }
99995   }
99996
99997   jresult = (void *)result;
99998   return jresult;
99999 }
100000
100001
100002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100004
100005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100006   {
100007     try {
100008       (*arg1)->DisableDomain();
100009     } catch (std::out_of_range& e) {
100010       {
100011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100012       };
100013     } catch (std::exception& e) {
100014       {
100015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100016       };
100017     } catch (Dali::DaliException e) {
100018       {
100019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100020       };
100021     } catch (...) {
100022       {
100023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100024       };
100025     }
100026   }
100027
100028 }
100029
100030
100031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100032   float jresult ;
100033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100034   float arg2 ;
100035   float arg3 ;
100036   float arg4 ;
100037   float result;
100038
100039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100040   arg2 = (float)jarg2;
100041   arg3 = (float)jarg3;
100042   arg4 = (float)jarg4;
100043   {
100044     try {
100045       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100046     } catch (std::out_of_range& e) {
100047       {
100048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100049       };
100050     } catch (std::exception& e) {
100051       {
100052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100053       };
100054     } catch (Dali::DaliException e) {
100055       {
100056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100057       };
100058     } catch (...) {
100059       {
100060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100061       };
100062     }
100063   }
100064
100065   jresult = result;
100066   return jresult;
100067 }
100068
100069
100070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100071   float jresult ;
100072   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100073   float arg2 ;
100074   float arg3 ;
100075   float result;
100076
100077   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100078   arg2 = (float)jarg2;
100079   arg3 = (float)jarg3;
100080   {
100081     try {
100082       result = (float)(*arg1)->Clamp(arg2,arg3);
100083     } catch (std::out_of_range& e) {
100084       {
100085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100086       };
100087     } catch (std::exception& e) {
100088       {
100089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100090       };
100091     } catch (Dali::DaliException e) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100094       };
100095     } catch (...) {
100096       {
100097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100098       };
100099     }
100100   }
100101
100102   jresult = result;
100103   return jresult;
100104 }
100105
100106
100107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100108   float jresult ;
100109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100110   float arg2 ;
100111   float result;
100112
100113   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100114   arg2 = (float)jarg2;
100115   {
100116     try {
100117       result = (float)(*arg1)->Clamp(arg2);
100118     } catch (std::out_of_range& e) {
100119       {
100120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100121       };
100122     } catch (std::exception& e) {
100123       {
100124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100125       };
100126     } catch (Dali::DaliException e) {
100127       {
100128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100129       };
100130     } catch (...) {
100131       {
100132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100133       };
100134     }
100135   }
100136
100137   jresult = result;
100138   return jresult;
100139 }
100140
100141
100142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100143   float jresult ;
100144   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100145   float arg2 ;
100146   float arg3 ;
100147   float arg4 ;
100148   Dali::Toolkit::ClampState *arg5 = 0 ;
100149   float result;
100150
100151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100152   arg2 = (float)jarg2;
100153   arg3 = (float)jarg3;
100154   arg4 = (float)jarg4;
100155   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100156   if (!arg5) {
100157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100158     return 0;
100159   }
100160   {
100161     try {
100162       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100163     } catch (std::out_of_range& e) {
100164       {
100165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100166       };
100167     } catch (std::exception& e) {
100168       {
100169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100170       };
100171     } catch (Dali::DaliException e) {
100172       {
100173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100174       };
100175     } catch (...) {
100176       {
100177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100178       };
100179     }
100180   }
100181
100182   jresult = result;
100183   return jresult;
100184 }
100185
100186
100187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100188   float jresult ;
100189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100190   float arg2 ;
100191   float arg3 ;
100192   float arg4 ;
100193   float arg5 ;
100194   float result;
100195
100196   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100197   arg2 = (float)jarg2;
100198   arg3 = (float)jarg3;
100199   arg4 = (float)jarg4;
100200   arg5 = (float)jarg5;
100201   {
100202     try {
100203       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100204     } catch (std::out_of_range& e) {
100205       {
100206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100207       };
100208     } catch (std::exception& e) {
100209       {
100210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100211       };
100212     } catch (Dali::DaliException e) {
100213       {
100214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100215       };
100216     } catch (...) {
100217       {
100218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100219       };
100220     }
100221   }
100222
100223   jresult = result;
100224   return jresult;
100225 }
100226
100227
100228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100229   float jresult ;
100230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100231   float arg2 ;
100232   float arg3 ;
100233   float arg4 ;
100234   float result;
100235
100236   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100237   arg2 = (float)jarg2;
100238   arg3 = (float)jarg3;
100239   arg4 = (float)jarg4;
100240   {
100241     try {
100242       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100243     } catch (std::out_of_range& e) {
100244       {
100245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100246       };
100247     } catch (std::exception& e) {
100248       {
100249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100250       };
100251     } catch (Dali::DaliException e) {
100252       {
100253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100254       };
100255     } catch (...) {
100256       {
100257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100258       };
100259     }
100260   }
100261
100262   jresult = result;
100263   return jresult;
100264 }
100265
100266
100267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100268   float jresult ;
100269   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100270   float arg2 ;
100271   float arg3 ;
100272   float result;
100273
100274   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100275   arg2 = (float)jarg2;
100276   arg3 = (float)jarg3;
100277   {
100278     try {
100279       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100280     } catch (std::out_of_range& e) {
100281       {
100282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100283       };
100284     } catch (std::exception& e) {
100285       {
100286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100287       };
100288     } catch (Dali::DaliException e) {
100289       {
100290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100291       };
100292     } catch (...) {
100293       {
100294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100295       };
100296     }
100297   }
100298
100299   jresult = result;
100300   return jresult;
100301 }
100302
100303
100304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100305   float jresult ;
100306   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100307   float arg2 ;
100308   float result;
100309
100310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100311   arg2 = (float)jarg2;
100312   {
100313     try {
100314       result = (float)(*arg1)->SnapAndClamp(arg2);
100315     } catch (std::out_of_range& e) {
100316       {
100317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (std::exception& e) {
100320       {
100321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100322       };
100323     } catch (Dali::DaliException e) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100326       };
100327     } catch (...) {
100328       {
100329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100330       };
100331     }
100332   }
100333
100334   jresult = result;
100335   return jresult;
100336 }
100337
100338
100339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100340   float jresult ;
100341   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100342   float arg2 ;
100343   float arg3 ;
100344   float arg4 ;
100345   float arg5 ;
100346   Dali::Toolkit::ClampState *arg6 = 0 ;
100347   float result;
100348
100349   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100350   arg2 = (float)jarg2;
100351   arg3 = (float)jarg3;
100352   arg4 = (float)jarg4;
100353   arg5 = (float)jarg5;
100354   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100355   if (!arg6) {
100356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100357     return 0;
100358   }
100359   {
100360     try {
100361       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100362     } catch (std::out_of_range& e) {
100363       {
100364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100365       };
100366     } catch (std::exception& e) {
100367       {
100368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100369       };
100370     } catch (Dali::DaliException e) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100373       };
100374     } catch (...) {
100375       {
100376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100377       };
100378     }
100379   }
100380
100381   jresult = result;
100382   return jresult;
100383 }
100384
100385
100386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100387   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100388
100389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100390   {
100391     try {
100392       (*arg1)->Reference();
100393     } catch (std::out_of_range& e) {
100394       {
100395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100396       };
100397     } catch (std::exception& e) {
100398       {
100399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100400       };
100401     } catch (Dali::DaliException e) {
100402       {
100403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100404       };
100405     } catch (...) {
100406       {
100407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100408       };
100409     }
100410   }
100411
100412 }
100413
100414
100415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100417
100418   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100419   {
100420     try {
100421       (*arg1)->Unreference();
100422     } catch (std::out_of_range& e) {
100423       {
100424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100425       };
100426     } catch (std::exception& e) {
100427       {
100428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100429       };
100430     } catch (Dali::DaliException e) {
100431       {
100432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100433       };
100434     } catch (...) {
100435       {
100436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100437       };
100438     }
100439   }
100440
100441 }
100442
100443
100444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100445   int jresult ;
100446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100447   int result;
100448
100449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100450   {
100451     try {
100452       result = (int)(*arg1)->ReferenceCount();
100453     } catch (std::out_of_range& e) {
100454       {
100455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100456       };
100457     } catch (std::exception& e) {
100458       {
100459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100460       };
100461     } catch (Dali::DaliException e) {
100462       {
100463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100464       };
100465     } catch (...) {
100466       {
100467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100468       };
100469     }
100470   }
100471
100472   jresult = result;
100473   return jresult;
100474 }
100475
100476
100477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100478   unsigned int jresult ;
100479   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100480   bool result;
100481
100482   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100483   {
100484     try {
100485       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100486     } catch (std::out_of_range& e) {
100487       {
100488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (std::exception& e) {
100491       {
100492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100493       };
100494     } catch (Dali::DaliException e) {
100495       {
100496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100497       };
100498     } catch (...) {
100499       {
100500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100501       };
100502     }
100503   }
100504
100505   jresult = result;
100506   return jresult;
100507 }
100508
100509
100510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100511   unsigned long jresult ;
100512   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100513   std::size_t result;
100514
100515   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100516   {
100517     try {
100518       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100519     } catch (std::out_of_range& e) {
100520       {
100521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100522       };
100523     } catch (std::exception& e) {
100524       {
100525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100526       };
100527     } catch (Dali::DaliException e) {
100528       {
100529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100530       };
100531     } catch (...) {
100532       {
100533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100534       };
100535     }
100536   }
100537
100538   jresult = (unsigned long)result;
100539   return jresult;
100540 }
100541
100542
100543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100544   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100545   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100546
100547   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100548   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100549   {
100550     try {
100551       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100552     } catch (std::out_of_range& e) {
100553       {
100554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100555       };
100556     } catch (std::exception& e) {
100557       {
100558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100559       };
100560     } catch (Dali::DaliException e) {
100561       {
100562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100563       };
100564     } catch (...) {
100565       {
100566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100567       };
100568     }
100569   }
100570
100571 }
100572
100573
100574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100575   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100576   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100577
100578   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100579   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100580   {
100581     try {
100582       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100583     } catch (std::out_of_range& e) {
100584       {
100585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100586       };
100587     } catch (std::exception& e) {
100588       {
100589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100590       };
100591     } catch (Dali::DaliException e) {
100592       {
100593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100594       };
100595     } catch (...) {
100596       {
100597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100598       };
100599     }
100600   }
100601
100602 }
100603
100604
100605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100606   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100607   Dali::Toolkit::Control arg2 ;
100608   Dali::Toolkit::Control *argp2 ;
100609
100610   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100611   argp2 = (Dali::Toolkit::Control *)jarg2;
100612   if (!argp2) {
100613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100614     return ;
100615   }
100616   arg2 = *argp2;
100617   {
100618     try {
100619       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100620     } catch (std::out_of_range& e) {
100621       {
100622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100623       };
100624     } catch (std::exception& e) {
100625       {
100626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100627       };
100628     } catch (Dali::DaliException e) {
100629       {
100630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100631       };
100632     } catch (...) {
100633       {
100634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100635       };
100636     }
100637   }
100638
100639 }
100640
100641
100642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100643   void * jresult ;
100644   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100645
100646   {
100647     try {
100648       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100649     } catch (std::out_of_range& e) {
100650       {
100651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100652       };
100653     } catch (std::exception& e) {
100654       {
100655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100656       };
100657     } catch (Dali::DaliException e) {
100658       {
100659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100660       };
100661     } catch (...) {
100662       {
100663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100664       };
100665     }
100666   }
100667
100668   jresult = (void *)result;
100669   return jresult;
100670 }
100671
100672
100673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100674   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100675
100676   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100677   {
100678     try {
100679       delete arg1;
100680     } catch (std::out_of_range& e) {
100681       {
100682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100683       };
100684     } catch (std::exception& e) {
100685       {
100686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100687       };
100688     } catch (Dali::DaliException e) {
100689       {
100690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100691       };
100692     } catch (...) {
100693       {
100694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100695       };
100696     }
100697   }
100698
100699 }
100700
100701 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100702   Dali::RefObject *result = NULL;
100703
100704   if (arg1)
100705   {
100706     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100707   }
100708   return result;
100709 }
100710
100711 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100712     return (Dali::RefObject *)jarg1;
100713 }
100714
100715 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100716     return (Dali::SignalObserver *)jarg1;
100717 }
100718
100719 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100720     return (Dali::ConnectionTrackerInterface *)jarg1;
100721 }
100722
100723 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100724     return (Dali::BaseHandle *)jarg1;
100725 }
100726
100727 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100728     return (Dali::BaseHandle *)jarg1;
100729 }
100730
100731 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100732     return (Dali::BaseHandle *)jarg1;
100733 }
100734
100735 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100736     return (Dali::BaseHandle *)jarg1;
100737 }
100738
100739 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100740     return (Dali::BaseHandle *)jarg1;
100741 }
100742
100743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100744     return (Dali::BaseHandle *)jarg1;
100745 }
100746
100747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100748     return (Dali::BaseHandle *)jarg1;
100749 }
100750
100751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100752     return (Dali::BaseHandle *)jarg1;
100753 }
100754
100755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100756     return (Dali::BaseHandle *)jarg1;
100757 }
100758
100759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100760     return (Dali::BaseHandle *)jarg1;
100761 }
100762
100763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100764     return (Dali::BaseHandle *)jarg1;
100765 }
100766
100767 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100768     return (Dali::BaseHandle *)jarg1;
100769 }
100770
100771 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100772     return (Dali::BaseHandle *)jarg1;
100773 }
100774
100775 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100776     return (Dali::Handle *)jarg1;
100777 }
100778
100779 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100780     return (Dali::Handle *)jarg1;
100781 }
100782
100783 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100784     return (Dali::BaseHandle *)jarg1;
100785 }
100786
100787 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100788     return (Dali::BaseHandle *)jarg1;
100789 }
100790
100791 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100792     return (Dali::Handle *)jarg1;
100793 }
100794
100795 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100796     return (Dali::BaseHandle *)jarg1;
100797 }
100798
100799 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100800     return (Dali::Handle *)jarg1;
100801 }
100802
100803 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100804     return (Dali::GestureDetector *)jarg1;
100805 }
100806
100807 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100808     return (Dali::Gesture *)jarg1;
100809 }
100810
100811 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100812     return (Dali::Handle *)jarg1;
100813 }
100814
100815 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100816     return (Dali::Actor *)jarg1;
100817 }
100818
100819 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100820     return (Dali::BaseHandle *)jarg1;
100821 }
100822
100823 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100824     return (Dali::RefObject *)jarg1;
100825 }
100826
100827 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100828     return (Dali::Actor *)jarg1;
100829 }
100830
100831 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100832     return (Dali::GestureDetector *)jarg1;
100833 }
100834
100835 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100836     return (Dali::Gesture *)jarg1;
100837 }
100838
100839 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100840     return (Dali::GestureDetector *)jarg1;
100841 }
100842
100843 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100844     return (Dali::Gesture *)jarg1;
100845 }
100846
100847 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100848     return (Dali::GestureDetector *)jarg1;
100849 }
100850
100851 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100852     return (Dali::Gesture *)jarg1;
100853 }
100854
100855 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100856     return (Dali::BaseHandle *)jarg1;
100857 }
100858
100859 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100860     return (Dali::Handle *)jarg1;
100861 }
100862
100863 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100864     return (Dali::Handle *)jarg1;
100865 }
100866
100867 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100868     return (Dali::Handle *)jarg1;
100869 }
100870
100871 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100872     return (Dali::Image *)jarg1;
100873 }
100874
100875 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100876     return (Dali::Image *)jarg1;
100877 }
100878
100879 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100880     return (Dali::Image *)jarg1;
100881 }
100882
100883 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100884     return (Dali::RefObject *)jarg1;
100885 }
100886
100887 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100888     return (Dali::Image *)jarg1;
100889 }
100890
100891 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100892     return (Dali::Image *)jarg1;
100893 }
100894
100895 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100896     return (Dali::ResourceImage *)jarg1;
100897 }
100898
100899 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100900     return (Dali::Actor *)jarg1;
100901 }
100902
100903 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100904     return (Dali::BaseHandle *)jarg1;
100905 }
100906
100907 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100908     return (Dali::BaseHandle *)jarg1;
100909 }
100910
100911
100912 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100913     return (Dali::BaseHandle *)jarg1;
100914 }
100915
100916 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100917     return (Dali::BaseHandle *)jarg1;
100918 }
100919
100920 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100921     return (Dali::CustomActorImpl *)jarg1;
100922 }
100923
100924 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100925     return (Dali::CustomActor *)jarg1;
100926 }
100927
100928 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100929     return (Dali::BaseHandle *)jarg1;
100930 }
100931
100932 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100933     return (Dali::Toolkit::Control *)jarg1;
100934 }
100935
100936 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100937     return (Dali::Toolkit::Control *)jarg1;
100938 }
100939
100940 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100941     return (Dali::Toolkit::Button *)jarg1;
100942 }
100943
100944 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100945     return (Dali::Toolkit::Button *)jarg1;
100946 }
100947
100948 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100949     return (Dali::Toolkit::Button *)jarg1;
100950 }
100951
100952 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100953     return (Dali::Toolkit::Control *)jarg1;
100954 }
100955
100956 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100957     return (Dali::Toolkit::Control *)jarg1;
100958 }
100959
100960 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100961     return (Dali::Toolkit::Control *)jarg1;
100962 }
100963
100964 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100965     return (Dali::Toolkit::Control *)jarg1;
100966 }
100967
100968 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100969     return (Dali::Toolkit::Control *)jarg1;
100970 }
100971
100972 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100973     return (Dali::RefObject *)jarg1;
100974 }
100975
100976 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100977     return (Dali::Toolkit::Scrollable *)jarg1;
100978 }
100979
100980 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100981     return (Dali::BaseHandle *)jarg1;
100982 }
100983
100984 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100985     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100986 }
100987
100988 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100989     return (Dali::RefObject *)jarg1;
100990 }
100991
100992 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100993     return (Dali::Toolkit::Ruler *)jarg1;
100994 }
100995
100996 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100997     return (Dali::Toolkit::Ruler *)jarg1;
100998 }
100999
101000 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101001     return (Dali::Toolkit::Scrollable *)jarg1;
101002 }
101003
101004 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101005     return (Dali::Toolkit::Control *)jarg1;
101006 }
101007
101008
101009 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101010     return (Dali::Toolkit::Control *)jarg1;
101011 }
101012
101013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101014     return (Dali::BaseHandle *)jarg1;
101015 }
101016
101017 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101018     return (Dali::BaseHandle *)jarg1;
101019 }
101020
101021 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101022     return (Dali::Toolkit::Control *)jarg1;
101023 }
101024
101025 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101026     return (Dali::Toolkit::Control *)jarg1;
101027 }
101028
101029 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101030     return (Dali::Toolkit::Control *)jarg1;
101031 }
101032
101033 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101034     return (Dali::Toolkit::Control *)jarg1;
101035 }
101036
101037 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101038     return (Dali::Toolkit::Control *)jarg1;
101039 }
101040
101041 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101042     return (Dali::Toolkit::Control *)jarg1;
101043 }
101044
101045 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101046     return (Dali::Toolkit::PageTurnView *)jarg1;
101047 }
101048
101049 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101050     return (Dali::Toolkit::PageTurnView *)jarg1;
101051 }
101052
101053 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101054     return (Dali::Toolkit::Button *)jarg1;
101055 }
101056
101057 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101058     return (Dali::BaseHandle *)jarg1;
101059 }
101060
101061 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101062     return (Dali::BaseHandle *)jarg1;
101063 }
101064
101065 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101066     return (Dali::BaseHandle *)jarg1;
101067 }
101068
101069
101070 //for PixelBuffer and ImageLoading
101071
101072 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101073     return (Dali::BaseHandle *)jarg1;
101074 }
101075
101076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101077   void * jresult ;
101078   unsigned int arg1 ;
101079   unsigned int arg2 ;
101080   Dali::Pixel::Format arg3 ;
101081   Dali::Devel::PixelBuffer result;
101082
101083   arg1 = (unsigned int)jarg1;
101084   arg2 = (unsigned int)jarg2;
101085   arg3 = (Dali::Pixel::Format)jarg3;
101086   {
101087     try {
101088       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101089     } catch (std::out_of_range& e) {
101090       {
101091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101092       };
101093     } catch (std::exception& e) {
101094       {
101095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101096       };
101097     } catch (...) {
101098       {
101099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101100       };
101101     }
101102   }
101103   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101104   return jresult;
101105 }
101106
101107
101108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101109   void * jresult ;
101110   Dali::Devel::PixelBuffer *result = 0 ;
101111
101112   {
101113     try {
101114       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101115     } catch (std::out_of_range& e) {
101116       {
101117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101118       };
101119     } catch (std::exception& e) {
101120       {
101121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101122       };
101123     } catch (...) {
101124       {
101125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101126       };
101127     }
101128   }
101129   jresult = (void *)result;
101130   return jresult;
101131 }
101132
101133
101134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101135   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101136
101137   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101138   {
101139     try {
101140       delete arg1;
101141     } catch (std::out_of_range& e) {
101142       {
101143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101144       };
101145     } catch (std::exception& e) {
101146       {
101147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101148       };
101149     } catch (...) {
101150       {
101151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101152       };
101153     }
101154   }
101155 }
101156
101157
101158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101159   void * jresult ;
101160   Dali::Devel::PixelBuffer *arg1 = 0 ;
101161   Dali::Devel::PixelBuffer *result = 0 ;
101162
101163   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101164   if (!arg1) {
101165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101166     return 0;
101167   }
101168   {
101169     try {
101170       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101171     } catch (std::out_of_range& e) {
101172       {
101173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101174       };
101175     } catch (std::exception& e) {
101176       {
101177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101178       };
101179     } catch (...) {
101180       {
101181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101182       };
101183     }
101184   }
101185   jresult = (void *)result;
101186   return jresult;
101187 }
101188
101189
101190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101191   void * jresult ;
101192   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101193   Dali::Devel::PixelBuffer *arg2 = 0 ;
101194   Dali::Devel::PixelBuffer *result = 0 ;
101195
101196   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101197   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101198   if (!arg2) {
101199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101200     return 0;
101201   }
101202   {
101203     try {
101204       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101205     } catch (std::out_of_range& e) {
101206       {
101207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101208       };
101209     } catch (std::exception& e) {
101210       {
101211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101212       };
101213     } catch (...) {
101214       {
101215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101216       };
101217     }
101218   }
101219   jresult = (void *)result;
101220   return jresult;
101221 }
101222
101223
101224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101225   void * jresult ;
101226   Dali::Devel::PixelBuffer *arg1 = 0 ;
101227   Dali::PixelData result;
101228
101229   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101230   if (!arg1) {
101231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101232     return 0;
101233   }
101234   {
101235     try {
101236       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101237     } catch (std::out_of_range& e) {
101238       {
101239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101240       };
101241     } catch (std::exception& e) {
101242       {
101243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101244       };
101245     } catch (...) {
101246       {
101247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101248       };
101249     }
101250   }
101251   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101252   return jresult;
101253 }
101254
101255
101256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101257   void * jresult ;
101258   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101259   Dali::PixelData result;
101260
101261   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101262   {
101263     try {
101264       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101265     } catch (std::out_of_range& e) {
101266       {
101267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101268       };
101269     } catch (std::exception& e) {
101270       {
101271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101272       };
101273     } catch (...) {
101274       {
101275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101276       };
101277     }
101278   }
101279   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101280   return jresult;
101281 }
101282
101283
101284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101285   void * jresult ;
101286   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101287   unsigned char *result = 0 ;
101288
101289   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101290   {
101291     try {
101292       result = (unsigned char *)(arg1)->GetBuffer();
101293     } catch (std::out_of_range& e) {
101294       {
101295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101296       };
101297     } catch (std::exception& e) {
101298       {
101299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101300       };
101301     } catch (...) {
101302       {
101303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101304       };
101305     }
101306   }
101307   jresult = (void *)result;
101308   return jresult;
101309 }
101310
101311
101312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101313   unsigned int jresult ;
101314   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101315   unsigned int result;
101316
101317   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101318   {
101319     try {
101320       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101321     } catch (std::out_of_range& e) {
101322       {
101323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101324       };
101325     } catch (std::exception& e) {
101326       {
101327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101328       };
101329     } catch (...) {
101330       {
101331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101332       };
101333     }
101334   }
101335   jresult = result;
101336   return jresult;
101337 }
101338
101339
101340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101341   unsigned int jresult ;
101342   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101343   unsigned int result;
101344
101345   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101346   {
101347     try {
101348       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101349     } catch (std::out_of_range& e) {
101350       {
101351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101352       };
101353     } catch (std::exception& e) {
101354       {
101355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101356       };
101357     } catch (...) {
101358       {
101359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101360       };
101361     }
101362   }
101363   jresult = result;
101364   return jresult;
101365 }
101366
101367
101368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101369   int jresult ;
101370   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101371   Dali::Pixel::Format result;
101372
101373   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101374   {
101375     try {
101376       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101377     } catch (std::out_of_range& e) {
101378       {
101379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101380       };
101381     } catch (std::exception& e) {
101382       {
101383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101384       };
101385     } catch (...) {
101386       {
101387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101388       };
101389     }
101390   }
101391   jresult = (int)result;
101392   return jresult;
101393 }
101394
101395
101396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101397   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101398   Dali::Devel::PixelBuffer arg2 ;
101399   float arg3 ;
101400   bool arg4 ;
101401   Dali::Devel::PixelBuffer *argp2 ;
101402
101403   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101404   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101405   if (!argp2) {
101406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101407     return ;
101408   }
101409   arg2 = *argp2;
101410   arg3 = (float)jarg3;
101411   arg4 = jarg4 ? true : false;
101412   {
101413     try {
101414       (arg1)->ApplyMask(arg2,arg3,arg4);
101415     } catch (std::out_of_range& e) {
101416       {
101417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101418       };
101419     } catch (std::exception& e) {
101420       {
101421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101422       };
101423     } catch (...) {
101424       {
101425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101426       };
101427     }
101428   }
101429 }
101430
101431
101432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101433   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101434   Dali::Devel::PixelBuffer arg2 ;
101435   float arg3 ;
101436   Dali::Devel::PixelBuffer *argp2 ;
101437
101438   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101439   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101440   if (!argp2) {
101441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101442     return ;
101443   }
101444   arg2 = *argp2;
101445   arg3 = (float)jarg3;
101446   {
101447     try {
101448       (arg1)->ApplyMask(arg2,arg3);
101449     } catch (std::out_of_range& e) {
101450       {
101451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101452       };
101453     } catch (std::exception& e) {
101454       {
101455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101456       };
101457     } catch (...) {
101458       {
101459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101460       };
101461     }
101462   }
101463 }
101464
101465
101466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101467   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101468   Dali::Devel::PixelBuffer arg2 ;
101469   Dali::Devel::PixelBuffer *argp2 ;
101470
101471   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101472   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101473   if (!argp2) {
101474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101475     return ;
101476   }
101477   arg2 = *argp2;
101478   {
101479     try {
101480       (arg1)->ApplyMask(arg2);
101481     } catch (std::out_of_range& e) {
101482       {
101483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101484       };
101485     } catch (std::exception& e) {
101486       {
101487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101488       };
101489     } catch (...) {
101490       {
101491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101492       };
101493     }
101494   }
101495 }
101496
101497
101498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101499   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101500   float arg2 ;
101501
101502   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101503   arg2 = (float)jarg2;
101504   {
101505     try {
101506       (arg1)->ApplyGaussianBlur(arg2);
101507     } catch (std::out_of_range& e) {
101508       {
101509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101510       };
101511     } catch (std::exception& e) {
101512       {
101513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101514       };
101515     } catch (...) {
101516       {
101517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101518       };
101519     }
101520   }
101521 }
101522
101523
101524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101525   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101526   uint16_t arg2 ;
101527   uint16_t arg3 ;
101528   uint16_t arg4 ;
101529   uint16_t arg5 ;
101530
101531   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101532   arg2 = (uint16_t)jarg2;
101533   arg3 = (uint16_t)jarg3;
101534   arg4 = (uint16_t)jarg4;
101535   arg5 = (uint16_t)jarg5;
101536   {
101537     try {
101538       (arg1)->Crop(arg2,arg3,arg4,arg5);
101539     } catch (std::out_of_range& e) {
101540       {
101541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101542       };
101543     } catch (std::exception& e) {
101544       {
101545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101546       };
101547     } catch (...) {
101548       {
101549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101550       };
101551     }
101552   }
101553 }
101554
101555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_GetMetadata(void * jarg1, void * jarg2) {
101556   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101557   Dali::Property::Map *arg2 = (Dali::Property::Map *) 0 ;
101558
101559   arg1 = (Dali::Devel::PixelBuffer*)jarg1;
101560   arg2 = (Dali::Property::Map*)jarg2;
101561   {
101562     try {
101563       (arg1)->GetMetadata(*arg2);
101564     } catch (std::out_of_range& e) {
101565       {
101566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101567       };
101568     } catch (std::exception& e) {
101569       {
101570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101571       };
101572     } catch (...) {
101573       {
101574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101575       };
101576     }
101577   }
101578 }
101579
101580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101581   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101582   uint16_t arg2 ;
101583   uint16_t arg3 ;
101584
101585   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101586   arg2 = (uint16_t)jarg2;
101587   arg3 = (uint16_t)jarg3;
101588   {
101589     try {
101590       (arg1)->Resize(arg2,arg3);
101591     } catch (std::out_of_range& e) {
101592       {
101593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101594       };
101595     } catch (std::exception& e) {
101596       {
101597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101598       };
101599     } catch (...) {
101600       {
101601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101602       };
101603     }
101604   }
101605 }
101606
101607
101608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
101609   void * jresult ;
101610   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
101611   Dali::Devel::PixelBuffer *result = 0 ;
101612
101613   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
101614   {
101615     try {
101616       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
101617     } catch (std::out_of_range& e) {
101618       {
101619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101620       };
101621     } catch (std::exception& e) {
101622       {
101623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101624       };
101625     } catch (...) {
101626       {
101627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101628       };
101629     }
101630   }
101631   jresult = (void *)result;
101632   return jresult;
101633 }
101634
101635
101636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101637   void * jresult ;
101638   std::string *arg1 = 0 ;
101639   Dali::ImageDimensions arg2 ;
101640   Dali::FittingMode::Type arg3 ;
101641   Dali::SamplingMode::Type arg4 ;
101642   bool arg5 ;
101643   Dali::ImageDimensions *argp2 ;
101644   Dali::Devel::PixelBuffer result;
101645
101646   if (!jarg1) {
101647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101648     return 0;
101649   }
101650   std::string arg1_str(jarg1);
101651   arg1 = &arg1_str;
101652   argp2 = (Dali::ImageDimensions *)jarg2;
101653   if (!argp2) {
101654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101655     return 0;
101656   }
101657   arg2 = *argp2;
101658   arg3 = (Dali::FittingMode::Type)jarg3;
101659   arg4 = (Dali::SamplingMode::Type)jarg4;
101660   arg5 = jarg5 ? true : false;
101661   {
101662     try {
101663       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101664     } catch (std::out_of_range& e) {
101665       {
101666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101667       };
101668     } catch (std::exception& e) {
101669       {
101670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101671       };
101672     } catch (...) {
101673       {
101674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101675       };
101676     }
101677   }
101678   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101679
101680   return jresult;
101681 }
101682
101683
101684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101685   void * jresult ;
101686   std::string *arg1 = 0 ;
101687   Dali::ImageDimensions arg2 ;
101688   Dali::FittingMode::Type arg3 ;
101689   Dali::SamplingMode::Type arg4 ;
101690   Dali::ImageDimensions *argp2 ;
101691   Dali::Devel::PixelBuffer result;
101692
101693   if (!jarg1) {
101694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101695     return 0;
101696   }
101697   std::string arg1_str(jarg1);
101698   arg1 = &arg1_str;
101699   argp2 = (Dali::ImageDimensions *)jarg2;
101700   if (!argp2) {
101701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101702     return 0;
101703   }
101704   arg2 = *argp2;
101705   arg3 = (Dali::FittingMode::Type)jarg3;
101706   arg4 = (Dali::SamplingMode::Type)jarg4;
101707   {
101708     try {
101709       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101710     } catch (std::out_of_range& e) {
101711       {
101712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101713       };
101714     } catch (std::exception& e) {
101715       {
101716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101717       };
101718     } catch (...) {
101719       {
101720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101721       };
101722     }
101723   }
101724   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101725
101726   return jresult;
101727 }
101728
101729
101730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101731   void * jresult ;
101732   std::string *arg1 = 0 ;
101733   Dali::ImageDimensions arg2 ;
101734   Dali::FittingMode::Type arg3 ;
101735   Dali::ImageDimensions *argp2 ;
101736   Dali::Devel::PixelBuffer result;
101737
101738   if (!jarg1) {
101739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101740     return 0;
101741   }
101742   std::string arg1_str(jarg1);
101743   arg1 = &arg1_str;
101744   argp2 = (Dali::ImageDimensions *)jarg2;
101745   if (!argp2) {
101746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101747     return 0;
101748   }
101749   arg2 = *argp2;
101750   arg3 = (Dali::FittingMode::Type)jarg3;
101751   {
101752     try {
101753       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101754     } catch (std::out_of_range& e) {
101755       {
101756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101757       };
101758     } catch (std::exception& e) {
101759       {
101760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101761       };
101762     } catch (...) {
101763       {
101764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101765       };
101766     }
101767   }
101768   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101769
101770   return jresult;
101771 }
101772
101773
101774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101775   void * jresult ;
101776   std::string *arg1 = 0 ;
101777   Dali::ImageDimensions arg2 ;
101778   Dali::ImageDimensions *argp2 ;
101779   Dali::Devel::PixelBuffer result;
101780
101781   if (!jarg1) {
101782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101783     return 0;
101784   }
101785   std::string arg1_str(jarg1);
101786   arg1 = &arg1_str;
101787   argp2 = (Dali::ImageDimensions *)jarg2;
101788   if (!argp2) {
101789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101790     return 0;
101791   }
101792   arg2 = *argp2;
101793   {
101794     try {
101795       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101796     } catch (std::out_of_range& e) {
101797       {
101798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101799       };
101800     } catch (std::exception& e) {
101801       {
101802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101803       };
101804     } catch (...) {
101805       {
101806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101807       };
101808     }
101809   }
101810   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101811
101812   return jresult;
101813 }
101814
101815
101816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101817   void * jresult ;
101818   std::string *arg1 = 0 ;
101819   Dali::Devel::PixelBuffer result;
101820
101821   if (!jarg1) {
101822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101823     return 0;
101824   }
101825   std::string arg1_str(jarg1);
101826   arg1 = &arg1_str;
101827   {
101828     try {
101829       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101830     } catch (std::out_of_range& e) {
101831       {
101832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101833       };
101834     } catch (std::exception& e) {
101835       {
101836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101837       };
101838     } catch (...) {
101839       {
101840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101841       };
101842     }
101843   }
101844   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101845
101846   return jresult;
101847 }
101848
101849
101850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101851   void * jresult ;
101852   std::string *arg1 = 0 ;
101853   Dali::ImageDimensions arg2 ;
101854   Dali::FittingMode::Type arg3 ;
101855   Dali::SamplingMode::Type arg4 ;
101856   bool arg5 ;
101857   Dali::ImageDimensions *argp2 ;
101858   Dali::ImageDimensions result;
101859
101860   if (!jarg1) {
101861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101862     return 0;
101863   }
101864   std::string arg1_str(jarg1);
101865   arg1 = &arg1_str;
101866   argp2 = (Dali::ImageDimensions *)jarg2;
101867   if (!argp2) {
101868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101869     return 0;
101870   }
101871   arg2 = *argp2;
101872   arg3 = (Dali::FittingMode::Type)jarg3;
101873   arg4 = (Dali::SamplingMode::Type)jarg4;
101874   arg5 = jarg5 ? true : false;
101875   {
101876     try {
101877       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101878     } catch (std::out_of_range& e) {
101879       {
101880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101881       };
101882     } catch (std::exception& e) {
101883       {
101884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101885       };
101886     } catch (...) {
101887       {
101888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101889       };
101890     }
101891   }
101892   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101893
101894   return jresult;
101895 }
101896
101897
101898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101899   void * jresult ;
101900   std::string *arg1 = 0 ;
101901   Dali::ImageDimensions arg2 ;
101902   Dali::FittingMode::Type arg3 ;
101903   Dali::SamplingMode::Type arg4 ;
101904   Dali::ImageDimensions *argp2 ;
101905   Dali::ImageDimensions result;
101906
101907   if (!jarg1) {
101908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101909     return 0;
101910   }
101911   std::string arg1_str(jarg1);
101912   arg1 = &arg1_str;
101913   argp2 = (Dali::ImageDimensions *)jarg2;
101914   if (!argp2) {
101915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101916     return 0;
101917   }
101918   arg2 = *argp2;
101919   arg3 = (Dali::FittingMode::Type)jarg3;
101920   arg4 = (Dali::SamplingMode::Type)jarg4;
101921   {
101922     try {
101923       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101924     } catch (std::out_of_range& e) {
101925       {
101926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101927       };
101928     } catch (std::exception& e) {
101929       {
101930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101931       };
101932     } catch (...) {
101933       {
101934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101935       };
101936     }
101937   }
101938   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101939
101940   return jresult;
101941 }
101942
101943
101944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101945   void * jresult ;
101946   std::string *arg1 = 0 ;
101947   Dali::ImageDimensions arg2 ;
101948   Dali::FittingMode::Type arg3 ;
101949   Dali::ImageDimensions *argp2 ;
101950   Dali::ImageDimensions result;
101951
101952   if (!jarg1) {
101953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101954     return 0;
101955   }
101956   std::string arg1_str(jarg1);
101957   arg1 = &arg1_str;
101958   argp2 = (Dali::ImageDimensions *)jarg2;
101959   if (!argp2) {
101960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101961     return 0;
101962   }
101963   arg2 = *argp2;
101964   arg3 = (Dali::FittingMode::Type)jarg3;
101965   {
101966     try {
101967       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101968     } catch (std::out_of_range& e) {
101969       {
101970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101971       };
101972     } catch (std::exception& e) {
101973       {
101974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101975       };
101976     } catch (...) {
101977       {
101978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101979       };
101980     }
101981   }
101982   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101983
101984   return jresult;
101985 }
101986
101987
101988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101989   void * jresult ;
101990   std::string *arg1 = 0 ;
101991   Dali::ImageDimensions arg2 ;
101992   Dali::ImageDimensions *argp2 ;
101993   Dali::ImageDimensions result;
101994
101995   if (!jarg1) {
101996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101997     return 0;
101998   }
101999   std::string arg1_str(jarg1);
102000   arg1 = &arg1_str;
102001   argp2 = (Dali::ImageDimensions *)jarg2;
102002   if (!argp2) {
102003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102004     return 0;
102005   }
102006   arg2 = *argp2;
102007   {
102008     try {
102009       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102010     } catch (std::out_of_range& e) {
102011       {
102012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102013       };
102014     } catch (std::exception& e) {
102015       {
102016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102017       };
102018     } catch (...) {
102019       {
102020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102021       };
102022     }
102023   }
102024   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102025
102026   return jresult;
102027 }
102028
102029
102030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102031   void * jresult ;
102032   std::string *arg1 = 0 ;
102033   Dali::ImageDimensions result;
102034
102035   if (!jarg1) {
102036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102037     return 0;
102038   }
102039   std::string arg1_str(jarg1);
102040   arg1 = &arg1_str;
102041   {
102042     try {
102043       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102044     } catch (std::out_of_range& e) {
102045       {
102046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102047       };
102048     } catch (std::exception& e) {
102049       {
102050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102051       };
102052     } catch (...) {
102053       {
102054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102055       };
102056     }
102057   }
102058   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102059
102060   return jresult;
102061 }
102062
102063
102064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102065   void * jresult ;
102066   std::string *arg1 = 0 ;
102067   Dali::ImageDimensions arg2 ;
102068   Dali::FittingMode::Type arg3 ;
102069   Dali::SamplingMode::Type arg4 ;
102070   bool arg5 ;
102071   Dali::ImageDimensions *argp2 ;
102072   Dali::Devel::PixelBuffer result;
102073
102074   if (!jarg1) {
102075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102076     return 0;
102077   }
102078   std::string arg1_str(jarg1);
102079   arg1 = &arg1_str;
102080   argp2 = (Dali::ImageDimensions *)jarg2;
102081   if (!argp2) {
102082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102083     return 0;
102084   }
102085   arg2 = *argp2;
102086   arg3 = (Dali::FittingMode::Type)jarg3;
102087   arg4 = (Dali::SamplingMode::Type)jarg4;
102088   arg5 = jarg5 ? true : false;
102089   {
102090     try {
102091       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102092     } catch (std::out_of_range& e) {
102093       {
102094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102095       };
102096     } catch (std::exception& e) {
102097       {
102098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102099       };
102100     } catch (...) {
102101       {
102102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102103       };
102104     }
102105   }
102106   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102107
102108   return jresult;
102109 }
102110
102111
102112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102113   void * jresult ;
102114   std::string *arg1 = 0 ;
102115   Dali::ImageDimensions arg2 ;
102116   Dali::FittingMode::Type arg3 ;
102117   Dali::SamplingMode::Type arg4 ;
102118   Dali::ImageDimensions *argp2 ;
102119   Dali::Devel::PixelBuffer result;
102120
102121   if (!jarg1) {
102122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102123     return 0;
102124   }
102125   std::string arg1_str(jarg1);
102126   arg1 = &arg1_str;
102127   argp2 = (Dali::ImageDimensions *)jarg2;
102128   if (!argp2) {
102129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102130     return 0;
102131   }
102132   arg2 = *argp2;
102133   arg3 = (Dali::FittingMode::Type)jarg3;
102134   arg4 = (Dali::SamplingMode::Type)jarg4;
102135   {
102136     try {
102137       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102138     } catch (std::out_of_range& e) {
102139       {
102140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102141       };
102142     } catch (std::exception& e) {
102143       {
102144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102145       };
102146     } catch (...) {
102147       {
102148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102149       };
102150     }
102151   }
102152   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102153
102154   return jresult;
102155 }
102156
102157
102158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102159   void * jresult ;
102160   std::string *arg1 = 0 ;
102161   Dali::ImageDimensions arg2 ;
102162   Dali::FittingMode::Type arg3 ;
102163   Dali::ImageDimensions *argp2 ;
102164   Dali::Devel::PixelBuffer result;
102165
102166   if (!jarg1) {
102167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102168     return 0;
102169   }
102170   std::string arg1_str(jarg1);
102171   arg1 = &arg1_str;
102172   argp2 = (Dali::ImageDimensions *)jarg2;
102173   if (!argp2) {
102174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102175     return 0;
102176   }
102177   arg2 = *argp2;
102178   arg3 = (Dali::FittingMode::Type)jarg3;
102179   {
102180     try {
102181       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102182     } catch (std::out_of_range& e) {
102183       {
102184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102185       };
102186     } catch (std::exception& e) {
102187       {
102188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102189       };
102190     } catch (...) {
102191       {
102192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102193       };
102194     }
102195   }
102196   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102197
102198   return jresult;
102199 }
102200
102201
102202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102203   void * jresult ;
102204   std::string *arg1 = 0 ;
102205   Dali::ImageDimensions arg2 ;
102206   Dali::ImageDimensions *argp2 ;
102207   Dali::Devel::PixelBuffer result;
102208
102209   if (!jarg1) {
102210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102211     return 0;
102212   }
102213   std::string arg1_str(jarg1);
102214   arg1 = &arg1_str;
102215   argp2 = (Dali::ImageDimensions *)jarg2;
102216   if (!argp2) {
102217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102218     return 0;
102219   }
102220   arg2 = *argp2;
102221   {
102222     try {
102223       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102224     } catch (std::out_of_range& e) {
102225       {
102226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102227       };
102228     } catch (std::exception& e) {
102229       {
102230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102231       };
102232     } catch (...) {
102233       {
102234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102235       };
102236     }
102237   }
102238   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102239
102240   return jresult;
102241 }
102242
102243
102244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102245   void * jresult ;
102246   std::string *arg1 = 0 ;
102247   Dali::Devel::PixelBuffer result;
102248
102249   if (!jarg1) {
102250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102251     return 0;
102252   }
102253   std::string arg1_str(jarg1);
102254   arg1 = &arg1_str;
102255   {
102256     try {
102257       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102258     } catch (std::out_of_range& e) {
102259       {
102260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102261       };
102262     } catch (std::exception& e) {
102263       {
102264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102265       };
102266     } catch (...) {
102267       {
102268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102269       };
102270     }
102271   }
102272   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102273
102274   return jresult;
102275 }
102276
102277
102278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
102279   unsigned int arg1 ;
102280
102281   arg1 = (unsigned int)jarg1;
102282   {
102283     try {
102284       Dali::SetMaxTextureSize(arg1);
102285     } catch (std::out_of_range& e) {
102286       {
102287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102288       };
102289     } catch (std::exception& e) {
102290       {
102291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102292       };
102293     } catch (...) {
102294       {
102295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102296       };
102297     }
102298   }
102299 }
102300
102301
102302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
102303   unsigned int jresult ;
102304   unsigned int result;
102305
102306   {
102307     try {
102308       result = (unsigned int)Dali::GetMaxTextureSize();
102309     } catch (std::out_of_range& e) {
102310       {
102311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102312       };
102313     } catch (std::exception& e) {
102314       {
102315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102316       };
102317     } catch (...) {
102318       {
102319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102320       };
102321     }
102322   }
102323   jresult = result;
102324   return jresult;
102325 }
102326
102327
102328 #ifdef __cplusplus
102329 }
102330 #endif