dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/window.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441 #include <dali/devel-api/adaptor-framework/window-devel.h>
 442
 443 #include <dali/devel-api/images/nine-patch-image.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/control-devel.h>
 451 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 452 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 459 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 460
 461 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 462 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 463 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 464
 465 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 466
 467 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 472
 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      // C++ code. DALi uses Handle <-> Body design pattern.
 626      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 627      // Handles in DALi can be converted into a boolean type
 628      // to check if the handle has a valid body attached to it.
 629      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 630      if( *self )
 631      {
 632        return true;
 633      }
 634      else
 635      {
 636        return false;
 637      }
 638     }
 639 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 640
 641      // C++ code. Check if two handles reference the same implemtion
 642      if( *self == rhs)
 643      {
 644        return true;
 645      }
 646      else
 647      {
 648        return false;
 649      }
 650     }
 651 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 652      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 653    }
 654 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){
 655      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 656    }
 657 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 658         std::vector< Dali::TouchPoint >* pv = 0;
 659         if (capacity >= 0) {
 660           pv = new std::vector< Dali::TouchPoint >();
 661           pv->reserve(capacity);
 662        } else {
 663           throw std::out_of_range("capacity");
 664        }
 665        return pv;
 666       }
 667 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 668         if (index>=0 && index<(int)self->size())
 669           return (*self)[index];
 670         else
 671           throw std::out_of_range("index");
 672       }
 673 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 674         if (index>=0 && index<(int)self->size())
 675           return (*self)[index];
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 680         if (index>=0 && index<(int)self->size())
 681           (*self)[index] = val;
 682         else
 683           throw std::out_of_range("index");
 684       }
 685 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 686         self->insert(self->end(), values.begin(), values.end());
 687       }
 688 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 689         if (index < 0)
 690           throw std::out_of_range("index");
 691         if (count < 0)
 692           throw std::out_of_range("count");
 693         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 694           throw std::invalid_argument("invalid range");
 695         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 696       }
 697 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 698         if (index>=0 && index<(int)self->size()+1)
 699           self->insert(self->begin()+index, x);
 700         else
 701           throw std::out_of_range("index");
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 704         if (index>=0 && index<(int)self->size()+1)
 705           self->insert(self->begin()+index, values.begin(), values.end());
 706         else
 707           throw std::out_of_range("index");
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 710         if (index>=0 && index<(int)self->size())
 711           self->erase(self->begin() + index);
 712         else
 713           throw std::out_of_range("index");
 714       }
 715 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 716         if (index < 0)
 717           throw std::out_of_range("index");
 718         if (count < 0)
 719           throw std::out_of_range("count");
 720         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 721           throw std::invalid_argument("invalid range");
 722         self->erase(self->begin()+index, self->begin()+index+count);
 723       }
 724 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 725         if (count < 0)
 726           throw std::out_of_range("count");
 727         return new std::vector< Dali::TouchPoint >(count, value);
 728       }
 729 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 730         std::reverse(self->begin(), self->end());
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 733         if (index < 0)
 734           throw std::out_of_range("index");
 735         if (count < 0)
 736           throw std::out_of_range("count");
 737         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 738           throw std::invalid_argument("invalid range");
 739         std::reverse(self->begin()+index, self->begin()+index+count);
 740       }
 741 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (index+values.size() > self->size())
 745           throw std::out_of_range("index");
 746         std::copy(values.begin(), values.end(), self->begin()+index);
 747       }
 748 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 749          return self->Empty();
 750       }
 751 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 752         return self->GetConnectionCount();
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 755           self->Connect( func );
 756       }
 757 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 758           self->Disconnect( func );
 759       }
 760 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 761           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 762 /*@SWIG@*/ self->Emit( arg );
 763       }
 764 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 765          return self->Empty();
 766       }
 767 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 768         return self->GetConnectionCount();
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 771           self->Connect( func );
 772       }
 773 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 774           self->Disconnect( func );
 775       }
 776 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 777           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 778 /*@SWIG@*/ self->Emit( arg );
 779       }
 780 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 781          return self->Empty();
 782       }
 783 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){
 784         return self->GetConnectionCount();
 785       }
 786 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 *)){
 787           self->Connect( func );
 788       }
 789 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 *)){
 790           self->Disconnect( func );
 791       }
 792 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){
 793           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 794 /*@SWIG@*/ self->Emit( arg );
 795       }
 796 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 797          return self->Empty();
 798       }
 799 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 800         return self->GetConnectionCount();
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 803           self->Connect( func );
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 806           self->Disconnect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 809           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 810 /*@SWIG@*/ self->Emit( arg );
 811       }
 812 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 813          return self->Empty();
 814       }
 815 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 816         return self->GetConnectionCount();
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 819           self->Connect( func );
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 822           self->Disconnect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 825           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 826 /*@SWIG@*/ self->Emit( arg );
 827       }
 828 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){
 829          return self->Empty();
 830       }
 831 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){
 832         return self->GetConnectionCount();
 833       }
 834 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 &)){
 835         self->Connect( func );
 836       }
 837 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 &)){
 838         self->Disconnect( func );
 839       }
 840 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){
 841         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 842 /*@SWIG@*/ self->Emit( arg1, arg2 );
 843       }
 844 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){
 845          return self->Empty();
 846       }
 847 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){
 848         return self->GetConnectionCount();
 849       }
 850 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 &)){
 851         self->Connect( func );
 852       }
 853 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 &)){
 854         self->Disconnect( func );
 855       }
 856 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){
 857         return self->Emit( arg1, arg2 );
 858       }
 859 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){
 860          return self->Empty();
 861       }
 862 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){
 863         return self->GetConnectionCount();
 864       }
 865 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 &)){
 866         self->Connect( func );
 867       }
 868 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 &)){
 869         self->Disconnect( func );
 870       }
 871 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){
 872         return self->Emit( arg1, arg2 );
 873       }
 874 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){
 875          return self->Empty();
 876       }
 877 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){
 878         return self->GetConnectionCount();
 879       }
 880 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 &)){
 881         self->Connect( func );
 882       }
 883 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 &)){
 884         self->Disconnect( func );
 885       }
 886 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){
 887         return self->Emit( arg1, arg2 );
 888       }
 889 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 890          return self->Empty();
 891       }
 892 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 893         return self->GetConnectionCount();
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 896           self->Connect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 899           self->Disconnect( func );
 900       }
 901 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 902           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 903 /*@SWIG@*/ self->Emit( arg );
 904       }
 905 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 906          return self->Empty();
 907       }
 908 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){
 909         return self->GetConnectionCount();
 910       }
 911 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 &)){
 912           self->Connect( func );
 913       }
 914 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 &)){
 915           self->Disconnect( func );
 916       }
 917 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){
 918           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 919 /*@SWIG@*/ self->Emit( arg );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928           self->Connect( func );
 929       }
 930 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 &)){
 931           self->Disconnect( func );
 932       }
 933 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){
 934           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 935 /*@SWIG@*/ self->Emit( arg );
 936       }
 937 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 938          return self->Empty();
 939       }
 940 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){
 941         return self->GetConnectionCount();
 942       }
 943 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 &)){
 944           self->Connect( func );
 945       }
 946 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 &)){
 947           self->Disconnect( func );
 948       }
 949 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){
 950           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 951 /*@SWIG@*/ self->Emit( arg );
 952       }
 953 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){
 954          return self->Empty();
 955       }
 956 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){
 957         return self->GetConnectionCount();
 958       }
 959 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 &)){
 960         self->Connect( func );
 961       }
 962 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 &)){
 963         self->Disconnect( func );
 964       }
 965 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){
 966         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 967 /*@SWIG@*/ self->Emit( arg1, arg2 );
 968       }
 969 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){
 970          return self->Empty();
 971       }
 972 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){
 973         return self->GetConnectionCount();
 974       }
 975 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 &)){
 976         self->Connect( func );
 977       }
 978 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 &)){
 979         self->Disconnect( func );
 980       }
 981 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){
 982         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 983 /*@SWIG@*/ self->Emit( arg1, arg2 );
 984       }
 985 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){
 986          return self->Empty();
 987       }
 988 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){
 989         return self->GetConnectionCount();
 990       }
 991 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 &)){
 992         self->Connect( func );
 993       }
 994 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 &)){
 995         self->Disconnect( func );
 996       }
 997 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){
 998         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 999 /*@SWIG@*/ self->Emit( arg1, arg2 );
1000       }
1001 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1002          return self->Empty();
1003       }
1004 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1005         return self->GetConnectionCount();
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1008           self->Connect( func );
1009       }
1010 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1011           self->Disconnect( func );
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1014           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1015 /*@SWIG@*/ self->Emit( arg );
1016       }
1017 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1018          return self->Empty();
1019       }
1020 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1021         return self->GetConnectionCount();
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1024           self->Connect( func );
1025       }
1026 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1027           self->Disconnect( func );
1028       }
1029 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1030           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1031 /*@SWIG@*/ self->Emit( arg );
1032       }
1033 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){
1034          return self->Empty();
1035       }
1036 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){
1037         return self->GetConnectionCount();
1038       }
1039 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)){
1040           return self->Connect( func );
1041       }
1042 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)){
1043           self->Disconnect( func );
1044       }
1045 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){
1046           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1048       }
1049
1050   // keep argcs and argv so they're always available to DALi
1051   int argC = 1;
1052   char **argV = NULL;
1053
1054 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1055          return self->Empty();
1056       }
1057 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1058         return self->GetConnectionCount();
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1061           self->Connect( func );
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1064           self->Disconnect( func );
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &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_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1071          return self->Empty();
1072       }
1073 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1074         return self->GetConnectionCount();
1075       }
1076 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1077         self->Connect( func );
1078       }
1079 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1080         self->Disconnect( func );
1081       }
1082 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1083         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1084 /*@SWIG@*/ self->Emit( arg1, arg2 );
1085       }
1086 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1087          return self->Empty();
1088       }
1089 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1090         return self->GetConnectionCount();
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1093           self->Connect( func );
1094       }
1095 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1096           self->Disconnect( func );
1097       }
1098 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1099           return self->Emit();
1100       }
1101 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1102          return self->Empty();
1103       }
1104 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1105         return self->GetConnectionCount();
1106       }
1107 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1108           self->Connect( func );
1109       }
1110 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1111           self->Disconnect( func );
1112       }
1113 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1114           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1115 /*@SWIG@*/ self->Emit( arg );
1116       }
1117 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1118         std::vector< unsigned int >* pv = 0;
1119         if (capacity >= 0) {
1120           pv = new std::vector< unsigned int >();
1121           pv->reserve(capacity);
1122        } else {
1123           throw std::out_of_range("capacity");
1124        }
1125        return pv;
1126       }
1127 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1128         if (index>=0 && index<(int)self->size())
1129           return (*self)[index];
1130         else
1131           throw std::out_of_range("index");
1132       }
1133 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           return (*self)[index];
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1140         if (index>=0 && index<(int)self->size())
1141           (*self)[index] = val;
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1146         self->insert(self->end(), values.begin(), values.end());
1147       }
1148 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1149         if (index < 0)
1150           throw std::out_of_range("index");
1151         if (count < 0)
1152           throw std::out_of_range("count");
1153         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1154           throw std::invalid_argument("invalid range");
1155         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1156       }
1157 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1158         if (index>=0 && index<(int)self->size()+1)
1159           self->insert(self->begin()+index, x);
1160         else
1161           throw std::out_of_range("index");
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1164         if (index>=0 && index<(int)self->size()+1)
1165           self->insert(self->begin()+index, values.begin(), values.end());
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1170         if (index>=0 && index<(int)self->size())
1171           self->erase(self->begin() + index);
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1176         if (index < 0)
1177           throw std::out_of_range("index");
1178         if (count < 0)
1179           throw std::out_of_range("count");
1180         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1181           throw std::invalid_argument("invalid range");
1182         self->erase(self->begin()+index, self->begin()+index+count);
1183       }
1184 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         return new std::vector< unsigned int >(count, value);
1188       }
1189 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1190         std::reverse(self->begin(), self->end());
1191       }
1192 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1193         if (index < 0)
1194           throw std::out_of_range("index");
1195         if (count < 0)
1196           throw std::out_of_range("count");
1197         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1198           throw std::invalid_argument("invalid range");
1199         std::reverse(self->begin()+index, self->begin()+index+count);
1200       }
1201 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1202         if (index < 0)
1203           throw std::out_of_range("index");
1204         if (index+values.size() > self->size())
1205           throw std::out_of_range("index");
1206         std::copy(values.begin(), values.end(), self->begin()+index);
1207       }
1208 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1209         return std::find(self->begin(), self->end(), value) != self->end();
1210       }
1211 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1212         int index = -1;
1213         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1214         if (it != self->end())
1215           index = (int)(it - self->begin());
1216         return index;
1217       }
1218 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1219         int index = -1;
1220         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1221         if (rit != self->rend())
1222           index = (int)(self->rend() - 1 - rit);
1223         return index;
1224       }
1225 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1226         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1227         if (it != self->end()) {
1228           self->erase(it);
1229           return true;
1230         }
1231         return false;
1232       }
1233 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){
1234         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1235         if (capacity >= 0) {
1236           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1237           pv->reserve(capacity);
1238        } else {
1239           throw std::out_of_range("capacity");
1240        }
1241        return pv;
1242       }
1243 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){
1244         if (index>=0 && index<(int)self->size())
1245           return (*self)[index];
1246         else
1247           throw std::out_of_range("index");
1248       }
1249 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){
1250         if (index>=0 && index<(int)self->size())
1251           return (*self)[index];
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 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){
1256         if (index>=0 && index<(int)self->size())
1257           (*self)[index] = val;
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 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){
1262         self->insert(self->end(), values.begin(), values.end());
1263       }
1264 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){
1265         if (index < 0)
1266           throw std::out_of_range("index");
1267         if (count < 0)
1268           throw std::out_of_range("count");
1269         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1270           throw std::invalid_argument("invalid range");
1271         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1272       }
1273 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){
1274         if (index>=0 && index<(int)self->size()+1)
1275           self->insert(self->begin()+index, x);
1276         else
1277           throw std::out_of_range("index");
1278       }
1279 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){
1280         if (index>=0 && index<(int)self->size()+1)
1281           self->insert(self->begin()+index, values.begin(), values.end());
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 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){
1286         if (index>=0 && index<(int)self->size())
1287           self->erase(self->begin() + index);
1288         else
1289           throw std::out_of_range("index");
1290       }
1291 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){
1292         if (index < 0)
1293           throw std::out_of_range("index");
1294         if (count < 0)
1295           throw std::out_of_range("count");
1296         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1297           throw std::invalid_argument("invalid range");
1298         self->erase(self->begin()+index, self->begin()+index+count);
1299       }
1300 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){
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1304       }
1305 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){
1306         std::reverse(self->begin(), self->end());
1307       }
1308 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){
1309         if (index < 0)
1310           throw std::out_of_range("index");
1311         if (count < 0)
1312           throw std::out_of_range("count");
1313         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1314           throw std::invalid_argument("invalid range");
1315         std::reverse(self->begin()+index, self->begin()+index+count);
1316       }
1317 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){
1318         if (index < 0)
1319           throw std::out_of_range("index");
1320         if (index+values.size() > self->size())
1321           throw std::out_of_range("index");
1322         std::copy(values.begin(), values.end(), self->begin()+index);
1323       }
1324 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1325         std::vector< Dali::Actor >* pv = 0;
1326         if (capacity >= 0) {
1327           pv = new std::vector< Dali::Actor >();
1328           pv->reserve(capacity);
1329        } else {
1330           throw std::out_of_range("capacity");
1331        }
1332        return pv;
1333       }
1334 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1335         if (index>=0 && index<(int)self->size())
1336           return (*self)[index];
1337         else
1338           throw std::out_of_range("index");
1339       }
1340 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           return (*self)[index];
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1347         if (index>=0 && index<(int)self->size())
1348           (*self)[index] = val;
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1353         self->insert(self->end(), values.begin(), values.end());
1354       }
1355 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1356         if (index < 0)
1357           throw std::out_of_range("index");
1358         if (count < 0)
1359           throw std::out_of_range("count");
1360         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1361           throw std::invalid_argument("invalid range");
1362         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1363       }
1364 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1365         if (index>=0 && index<(int)self->size()+1)
1366           self->insert(self->begin()+index, x);
1367         else
1368           throw std::out_of_range("index");
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1371         if (index>=0 && index<(int)self->size()+1)
1372           self->insert(self->begin()+index, values.begin(), values.end());
1373         else
1374           throw std::out_of_range("index");
1375       }
1376 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1377         if (index>=0 && index<(int)self->size())
1378           self->erase(self->begin() + index);
1379         else
1380           throw std::out_of_range("index");
1381       }
1382 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1383         if (index < 0)
1384           throw std::out_of_range("index");
1385         if (count < 0)
1386           throw std::out_of_range("count");
1387         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1388           throw std::invalid_argument("invalid range");
1389         self->erase(self->begin()+index, self->begin()+index+count);
1390       }
1391 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         return new std::vector< Dali::Actor >(count, value);
1395       }
1396 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1397         std::reverse(self->begin(), self->end());
1398       }
1399 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1400         if (index < 0)
1401           throw std::out_of_range("index");
1402         if (count < 0)
1403           throw std::out_of_range("count");
1404         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1405           throw std::invalid_argument("invalid range");
1406         std::reverse(self->begin()+index, self->begin()+index+count);
1407       }
1408 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1409         if (index < 0)
1410           throw std::out_of_range("index");
1411         if (index+values.size() > self->size())
1412           throw std::out_of_range("index");
1413         std::copy(values.begin(), values.end(), self->begin()+index);
1414       }
1415 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1416          return self->Empty();
1417       }
1418 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1419         return self->GetConnectionCount();
1420       }
1421 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 &)){
1422           self->Connect( func );
1423       }
1424 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 &)){
1425           self->Disconnect( func );
1426       }
1427 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){
1428           return self->Emit( arg );
1429       }
1430 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){
1431          return self->Empty();
1432       }
1433 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){
1434         return self->GetConnectionCount();
1435       }
1436 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)){
1437         self->Connect( func );
1438       }
1439 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)){
1440         self->Disconnect( func );
1441       }
1442 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){
1443         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1444 /*@SWIG@*/ self->Emit( arg1, arg2 );
1445       }
1446 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1447          return self->Empty();
1448       }
1449 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){
1450         return self->GetConnectionCount();
1451       }
1452 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)){
1453         self->Connect( func );
1454       }
1455 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)){
1456         self->Disconnect( func );
1457       }
1458 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){
1459         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1460 /*@SWIG@*/ self->Emit( arg1, arg2 );
1461       }
1462 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1463          return self->Empty();
1464       }
1465 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1466         return self->GetConnectionCount();
1467       }
1468 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)){
1469         self->Connect( func );
1470       }
1471 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)){
1472         self->Disconnect( func );
1473       }
1474 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){
1475         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1476 /*@SWIG@*/ self->Emit( arg1, arg2 );
1477       }
1478 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){
1479          return self->Empty();
1480       }
1481 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){
1482         return self->GetConnectionCount();
1483       }
1484 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)){
1485         self->Connect( func );
1486       }
1487 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)){
1488         self->Disconnect( func );
1489       }
1490 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){
1491         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1492 /*@SWIG@*/ self->Emit( arg1, arg2 );
1493       }
1494 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1495          return self->Empty();
1496       }
1497 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1498         return self->GetConnectionCount();
1499       }
1500 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)){
1501           self->Connect( func );
1502       }
1503 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)){
1504           self->Disconnect( func );
1505       }
1506 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1507           return self->Emit( arg );
1508       }
1509 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1510          return self->Empty();
1511       }
1512 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1513         return self->GetConnectionCount();
1514       }
1515 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)){
1516           self->Connect( func );
1517       }
1518 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)){
1519           self->Disconnect( func );
1520       }
1521 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1522           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1523 /*@SWIG@*/ self->Emit( arg );
1524       }
1525 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){
1526          return self->Empty();
1527       }
1528 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){
1529         return self->GetConnectionCount();
1530       }
1531 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)){
1532           return self->Connect( func );
1533       }
1534 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)){
1535           self->Disconnect( func );
1536       }
1537 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){
1538           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1539 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1540       }
1541 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1542          return self->Empty();
1543       }
1544 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1545         return self->GetConnectionCount();
1546       }
1547 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)){
1548           self->Connect( func );
1549       }
1550 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)){
1551           self->Disconnect( func );
1552       }
1553 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1554           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1555 /*@SWIG@*/ self->Emit( arg );
1556       }
1557 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){
1558          return self->Empty();
1559       }
1560 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){
1561         return self->GetConnectionCount();
1562       }
1563 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)){
1564           return self->Connect( func );
1565       }
1566 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)){
1567           self->Disconnect( func );
1568       }
1569 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){
1570           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1571 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1572       }
1573 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){
1574          return self->Empty();
1575       }
1576 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){
1577         return self->GetConnectionCount();
1578       }
1579 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 &)){
1580           self->Connect( func );
1581       }
1582 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 &)){
1583           self->Disconnect( func );
1584       }
1585 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){
1586           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1587 /*@SWIG@*/ self->Emit( arg );
1588       }
1589 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1590          return self->Empty();
1591       }
1592 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){
1593         return self->GetConnectionCount();
1594       }
1595 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 &)){
1596           self->Connect( func );
1597       }
1598 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 &)){
1599           self->Disconnect( func );
1600       }
1601 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){
1602           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1603 /*@SWIG@*/ self->Emit( arg );
1604       }
1605 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1606          return self->Empty();
1607       }
1608 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1609         return self->GetConnectionCount();
1610       }
1611 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1612           self->Connect( func );
1613       }
1614 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1615           self->Disconnect( func );
1616       }
1617 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1618           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1619 /*@SWIG@*/ self->Emit( arg );
1620       }
1621 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1622          return self->Empty();
1623       }
1624 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1625         return self->GetConnectionCount();
1626       }
1627 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1628           self->Connect( func );
1629       }
1630 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1631           self->Disconnect( func );
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1634           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1635 /*@SWIG@*/ self->Emit( arg );
1636       }
1637 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){
1638          return self->Empty();
1639       }
1640 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){
1641         return self->GetConnectionCount();
1642       }
1643 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 &)){
1644         self->Connect( func );
1645       }
1646 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 &)){
1647         self->Disconnect( func );
1648       }
1649 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){
1650         return self->Emit( arg1, arg2 );
1651       }
1652 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1653          return self->Empty();
1654       }
1655 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1656         return self->GetConnectionCount();
1657       }
1658 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)){
1659           self->Connect( func );
1660       }
1661 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)){
1662           self->Disconnect( func );
1663       }
1664 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1665           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1666 /*@SWIG@*/ self->Emit( arg );
1667       }
1668 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1669          return self->Empty();
1670       }
1671 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1672         return self->GetConnectionCount();
1673       }
1674 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 &)){
1675           self->Connect( func );
1676       }
1677 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 &)){
1678           self->Disconnect( func );
1679       }
1680 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){
1681           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1682 /*@SWIG@*/ self->Emit( arg );
1683       }
1684 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1685          return self->Empty();
1686       }
1687 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){
1688         return self->GetConnectionCount();
1689       }
1690 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)){
1691         self->Connect( func );
1692       }
1693 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)){
1694         self->Disconnect( func );
1695       }
1696 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){
1697         return self->Emit( arg1, arg2 );
1698       }
1699 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1700          return self->Empty();
1701       }
1702 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){
1703         return self->GetConnectionCount();
1704       }
1705 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)){
1706         self->Connect( func );
1707       }
1708 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)){
1709         self->Disconnect( func );
1710       }
1711 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){
1712         return self->Emit( arg1, arg2 );
1713       }
1714
1715
1716 /* ---------------------------------------------------
1717  * C++ director class methods
1718  * --------------------------------------------------- */
1719
1720 #include "dali_wrap.h"
1721
1722 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1723   swig_init_callbacks();
1724 }
1725
1726 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1727
1728 }
1729
1730
1731 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1732   int jdepth  ;
1733
1734   if (!swig_callbackOnStageConnection) {
1735     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1736     return;
1737   } else {
1738     jdepth = depth;
1739     swig_callbackOnStageConnection(jdepth);
1740   }
1741 }
1742
1743 void SwigDirector_ViewImpl::OnStageDisconnection() {
1744   if (!swig_callbackOnStageDisconnection) {
1745     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1746     return;
1747   } else {
1748     swig_callbackOnStageDisconnection();
1749   }
1750 }
1751
1752 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1753   void * jchild = 0 ;
1754
1755   if (!swig_callbackOnChildAdd) {
1756     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1757     return;
1758   } else {
1759     jchild = (Dali::Actor *) &child;
1760     swig_callbackOnChildAdd(jchild);
1761   }
1762 }
1763
1764 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1765   void * jchild = 0 ;
1766
1767   if (!swig_callbackOnChildRemove) {
1768     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1769     return;
1770   } else {
1771     jchild = (Dali::Actor *) &child;
1772     swig_callbackOnChildRemove(jchild);
1773   }
1774 }
1775
1776 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1777   int jindex  ;
1778   void * jpropertyValue  ;
1779
1780   if (!swig_callbackOnPropertySet) {
1781     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1782     return;
1783   } else {
1784     jindex = index;
1785     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1786     swig_callbackOnPropertySet(jindex, jpropertyValue);
1787   }
1788 }
1789
1790 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1791   void * jtargetSize = 0 ;
1792
1793   if (!swig_callbackOnSizeSet) {
1794     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1795     return;
1796   } else {
1797     jtargetSize = (Dali::Vector3 *) &targetSize;
1798     swig_callbackOnSizeSet(jtargetSize);
1799   }
1800 }
1801
1802 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1803   void * janimation = 0 ;
1804   void * jtargetSize = 0 ;
1805
1806   if (!swig_callbackOnSizeAnimation) {
1807     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1808     return;
1809   } else {
1810     janimation = (Dali::Animation *) &animation;
1811     jtargetSize = (Dali::Vector3 *) &targetSize;
1812     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1813   }
1814 }
1815
1816 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1817   bool c_result = SwigValueInit< bool >() ;
1818   unsigned int jresult = 0 ;
1819   void * jarg0 = 0 ;
1820
1821   if (!swig_callbackOnTouchEvent) {
1822     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1823   } else {
1824     jarg0 = (Dali::TouchEvent *) &event;
1825     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1826     c_result = jresult ? true : false;
1827   }
1828   return c_result;
1829 }
1830
1831 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1832   bool c_result = SwigValueInit< bool >() ;
1833   unsigned int jresult = 0 ;
1834   void * jarg0 = 0 ;
1835
1836   if (!swig_callbackOnHoverEvent) {
1837     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1838   } else {
1839     jarg0 = (Dali::HoverEvent *) &event;
1840     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1841     c_result = jresult ? true : false;
1842   }
1843   return c_result;
1844 }
1845
1846 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1847   bool c_result = SwigValueInit< bool >() ;
1848   unsigned int jresult = 0 ;
1849   void * jarg0 = 0 ;
1850
1851   if (!swig_callbackOnKeyEvent) {
1852     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1853   } else {
1854     jarg0 = (Dali::KeyEvent *) &event;
1855     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1856     c_result = jresult ? true : false;
1857   }
1858   return c_result;
1859 }
1860
1861 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1862   bool c_result = SwigValueInit< bool >() ;
1863   unsigned int jresult = 0 ;
1864   void * jarg0 = 0 ;
1865
1866   if (!swig_callbackOnWheelEvent) {
1867     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1868   } else {
1869     jarg0 = (Dali::WheelEvent *) &event;
1870     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1871     c_result = jresult ? true : false;
1872   }
1873   return c_result;
1874 }
1875
1876 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1877   void * jsize = 0 ;
1878   void * jcontainer = 0 ;
1879
1880   if (!swig_callbackOnRelayout) {
1881     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1882     return;
1883   } else {
1884     jsize = (Dali::Vector2 *) &size;
1885     jcontainer = (Dali::RelayoutContainer *) &container;
1886     swig_callbackOnRelayout(jsize, jcontainer);
1887   }
1888 }
1889
1890 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1891   int jpolicy  ;
1892   int jdimension  ;
1893
1894   if (!swig_callbackOnSetResizePolicy) {
1895     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1896     return;
1897   } else {
1898     jpolicy = (int)policy;
1899     jdimension = (int)dimension;
1900     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1901   }
1902 }
1903
1904 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1905   Dali::Vector3 c_result ;
1906   void * jresult = 0 ;
1907
1908   if (!swig_callbackGetNaturalSize) {
1909     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1910   } else {
1911     jresult = (void *) swig_callbackGetNaturalSize();
1912     if (!jresult) {
1913       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1914       return c_result;
1915     }
1916     c_result = *(Dali::Vector3 *)jresult;
1917   }
1918   return c_result;
1919 }
1920
1921 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1922   float c_result = SwigValueInit< float >() ;
1923   float jresult = 0 ;
1924   void * jchild = 0 ;
1925   int jdimension  ;
1926
1927   if (!swig_callbackCalculateChildSize) {
1928     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1929   } else {
1930     jchild = (Dali::Actor *) &child;
1931     jdimension = (int)dimension;
1932     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1933     c_result = (float)jresult;
1934   }
1935   return c_result;
1936 }
1937
1938 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1939   float c_result = SwigValueInit< float >() ;
1940   float jresult = 0 ;
1941   float jwidth  ;
1942
1943   if (!swig_callbackGetHeightForWidth) {
1944     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1945   } else {
1946     jwidth = width;
1947     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1948     c_result = (float)jresult;
1949   }
1950   return c_result;
1951 }
1952
1953 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1954   float c_result = SwigValueInit< float >() ;
1955   float jresult = 0 ;
1956   float jheight  ;
1957
1958   if (!swig_callbackGetWidthForHeight) {
1959     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1960   } else {
1961     jheight = height;
1962     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1963     c_result = (float)jresult;
1964   }
1965   return c_result;
1966 }
1967
1968 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1969   bool c_result = SwigValueInit< bool >() ;
1970   unsigned int jresult = 0 ;
1971   int jdimension  ;
1972
1973   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1974     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1975   } else {
1976     jdimension = (int)dimension;
1977     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1978     c_result = jresult ? true : false;
1979   }
1980   return c_result;
1981 }
1982
1983 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1984   int jdimension  ;
1985
1986   if (!swig_callbackOnCalculateRelayoutSize) {
1987     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1988     return;
1989   } else {
1990     jdimension = (int)dimension;
1991     swig_callbackOnCalculateRelayoutSize(jdimension);
1992   }
1993 }
1994
1995 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1996   float jsize  ;
1997   int jdimension  ;
1998
1999   if (!swig_callbackOnLayoutNegotiated) {
2000     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2001     return;
2002   } else {
2003     jsize = size;
2004     jdimension = (int)dimension;
2005     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2006   }
2007 }
2008
2009 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2010   return Dali::CustomActorImpl::GetExtension();
2011 }
2012
2013 void SwigDirector_ViewImpl::OnInitialize() {
2014   if (!swig_callbackOnInitialize) {
2015     Dali::Toolkit::Internal::Control::OnInitialize();
2016     return;
2017   } else {
2018     swig_callbackOnInitialize();
2019   }
2020 }
2021
2022 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2023   void * jchild = 0 ;
2024
2025   if (!swig_callbackOnControlChildAdd) {
2026     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2027     return;
2028   } else {
2029     jchild = (Dali::Actor *) &child;
2030     swig_callbackOnControlChildAdd(jchild);
2031   }
2032 }
2033
2034 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2035   void * jchild = 0 ;
2036
2037   if (!swig_callbackOnControlChildRemove) {
2038     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2039     return;
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     swig_callbackOnControlChildRemove(jchild);
2043   }
2044 }
2045
2046 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2047   void * jstyleManager  ;
2048   int jchange  ;
2049
2050   if (!swig_callbackOnStyleChange) {
2051     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2052     return;
2053   } else {
2054     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2055     jchange = (int)change;
2056     swig_callbackOnStyleChange(jstyleManager, jchange);
2057   }
2058 }
2059
2060 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2061   bool c_result = SwigValueInit< bool >() ;
2062   unsigned int jresult = 0 ;
2063
2064   if (!swig_callbackOnAccessibilityActivated) {
2065     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2066   } else {
2067     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2068     c_result = jresult ? true : false;
2069   }
2070   return c_result;
2071 }
2072
2073 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2074   bool c_result = SwigValueInit< bool >() ;
2075   unsigned int jresult = 0 ;
2076   void * jgesture  ;
2077
2078   if (!swig_callbackOnAccessibilityPan) {
2079     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2080   } else {
2081     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2082     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2083     c_result = jresult ? true : false;
2084   }
2085   return c_result;
2086 }
2087
2088 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2089   bool c_result = SwigValueInit< bool >() ;
2090   unsigned int jresult = 0 ;
2091   void * jtouchEvent = 0 ;
2092
2093   if (!swig_callbackOnAccessibilityTouch) {
2094     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2095   } else {
2096     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2097     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2098     c_result = jresult ? true : false;
2099   }
2100   return c_result;
2101 }
2102
2103 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2104   bool c_result = SwigValueInit< bool >() ;
2105   unsigned int jresult = 0 ;
2106   unsigned int jisIncrease  ;
2107
2108   if (!swig_callbackOnAccessibilityValueChange) {
2109     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2110   } else {
2111     jisIncrease = isIncrease;
2112     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2113     c_result = jresult ? true : false;
2114   }
2115   return c_result;
2116 }
2117
2118 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2119   bool c_result = SwigValueInit< bool >() ;
2120   unsigned int jresult = 0 ;
2121
2122   if (!swig_callbackOnAccessibilityZoom) {
2123     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2124   } else {
2125     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2126     c_result = jresult ? true : false;
2127   }
2128   return c_result;
2129 }
2130
2131 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2132   if (!swig_callbackOnKeyInputFocusGained) {
2133     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2134     return;
2135   } else {
2136     swig_callbackOnKeyInputFocusGained();
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2141   if (!swig_callbackOnKeyInputFocusLost) {
2142     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2143     return;
2144   } else {
2145     swig_callbackOnKeyInputFocusLost();
2146   }
2147 }
2148
2149 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2150   Dali::Actor c_result ;
2151   void * jresult = 0 ;
2152   void * jcurrentFocusedActor  ;
2153   int jdirection  ;
2154   unsigned int jloopEnabled  ;
2155
2156   if (!swig_callbackGetNextKeyboardFocusableActor) {
2157     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2158   } else {
2159     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2160     jdirection = (int)direction;
2161     jloopEnabled = loopEnabled;
2162     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2163     if (!jresult) {
2164       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2165       return c_result;
2166     }
2167     c_result = *(Dali::Actor *)jresult;
2168   }
2169   return c_result;
2170 }
2171
2172 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2173   void * jcommitedFocusableActor  ;
2174
2175   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2176     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2177     return;
2178   } else {
2179     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2180     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2181   }
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187
2188   if (!swig_callbackOnKeyboardEnter) {
2189     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2190   } else {
2191     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2192     c_result = jresult ? true : false;
2193   }
2194   return c_result;
2195 }
2196
2197 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2198   void * jpinch = 0 ;
2199
2200   if (!swig_callbackOnPinch) {
2201     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2202     return;
2203   } else {
2204     jpinch = (Dali::PinchGesture *) &pinch;
2205     swig_callbackOnPinch(jpinch);
2206   }
2207 }
2208
2209 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2210   void * jpan = 0 ;
2211
2212   if (!swig_callbackOnPan) {
2213     Dali::Toolkit::Internal::Control::OnPan(pan);
2214     return;
2215   } else {
2216     jpan = (Dali::PanGesture *) &pan;
2217     swig_callbackOnPan(jpan);
2218   }
2219 }
2220
2221 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2222   void * jtap = 0 ;
2223
2224   if (!swig_callbackOnTap) {
2225     Dali::Toolkit::Internal::Control::OnTap(tap);
2226     return;
2227   } else {
2228     jtap = (Dali::TapGesture *) &tap;
2229     swig_callbackOnTap(jtap);
2230   }
2231 }
2232
2233 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2234   void * jlongPress = 0 ;
2235
2236   if (!swig_callbackOnLongPress) {
2237     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2238     return;
2239   } else {
2240     jlongPress = (Dali::LongPressGesture *) &longPress;
2241     swig_callbackOnLongPress(jlongPress);
2242   }
2243 }
2244
2245 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2246   void * jslotObserver = 0 ;
2247   void * jcallback = 0 ;
2248
2249   if (!swig_callbackSignalConnected) {
2250     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2251     return;
2252   } else {
2253     jslotObserver = (void *) slotObserver;
2254     jcallback = (void *) callback;
2255     swig_callbackSignalConnected(jslotObserver, jcallback);
2256   }
2257 }
2258
2259 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2260   void * jslotObserver = 0 ;
2261   void * jcallback = 0 ;
2262
2263   if (!swig_callbackSignalDisconnected) {
2264     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2265     return;
2266   } else {
2267     jslotObserver = (void *) slotObserver;
2268     jcallback = (void *) callback;
2269     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2270   }
2271 }
2272
2273 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2274   return Dali::Toolkit::Internal::Control::GetControlExtension();
2275 }
2276
2277 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) {
2278   swig_callbackOnStageConnection = callbackOnStageConnection;
2279   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2280   swig_callbackOnChildAdd = callbackOnChildAdd;
2281   swig_callbackOnChildRemove = callbackOnChildRemove;
2282   swig_callbackOnPropertySet = callbackOnPropertySet;
2283   swig_callbackOnSizeSet = callbackOnSizeSet;
2284   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2285   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2286   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2287   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2288   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2289   swig_callbackOnRelayout = callbackOnRelayout;
2290   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2291   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2292   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2293   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2294   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2295   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2296   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2297   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2298   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2299   swig_callbackOnInitialize = callbackOnInitialize;
2300   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2301   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2302   swig_callbackOnStyleChange = callbackOnStyleChange;
2303   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2304   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2305   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2306   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2307   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2308   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2309   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2310   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2311   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2312   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2313   swig_callbackOnPinch = callbackOnPinch;
2314   swig_callbackOnPan = callbackOnPan;
2315   swig_callbackOnTap = callbackOnTap;
2316   swig_callbackOnLongPress = callbackOnLongPress;
2317   swig_callbackSignalConnected = callbackSignalConnected;
2318   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2319 }
2320
2321 void SwigDirector_ViewImpl::swig_init_callbacks() {
2322   swig_callbackOnStageConnection = 0;
2323   swig_callbackOnStageDisconnection = 0;
2324   swig_callbackOnChildAdd = 0;
2325   swig_callbackOnChildRemove = 0;
2326   swig_callbackOnPropertySet = 0;
2327   swig_callbackOnSizeSet = 0;
2328   swig_callbackOnSizeAnimation = 0;
2329   swig_callbackOnTouchEvent = 0;
2330   swig_callbackOnHoverEvent = 0;
2331   swig_callbackOnKeyEvent = 0;
2332   swig_callbackOnWheelEvent = 0;
2333   swig_callbackOnRelayout = 0;
2334   swig_callbackOnSetResizePolicy = 0;
2335   swig_callbackGetNaturalSize = 0;
2336   swig_callbackCalculateChildSize = 0;
2337   swig_callbackGetHeightForWidth = 0;
2338   swig_callbackGetWidthForHeight = 0;
2339   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2340   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2341   swig_callbackOnCalculateRelayoutSize = 0;
2342   swig_callbackOnLayoutNegotiated = 0;
2343   swig_callbackOnInitialize = 0;
2344   swig_callbackOnControlChildAdd = 0;
2345   swig_callbackOnControlChildRemove = 0;
2346   swig_callbackOnStyleChange = 0;
2347   swig_callbackOnAccessibilityActivated = 0;
2348   swig_callbackOnAccessibilityPan = 0;
2349   swig_callbackOnAccessibilityTouch = 0;
2350   swig_callbackOnAccessibilityValueChange = 0;
2351   swig_callbackOnAccessibilityZoom = 0;
2352   swig_callbackOnKeyInputFocusGained = 0;
2353   swig_callbackOnKeyInputFocusLost = 0;
2354   swig_callbackGetNextKeyboardFocusableActor = 0;
2355   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2356   swig_callbackOnKeyboardEnter = 0;
2357   swig_callbackOnPinch = 0;
2358   swig_callbackOnPan = 0;
2359   swig_callbackOnTap = 0;
2360   swig_callbackOnLongPress = 0;
2361   swig_callbackSignalConnected = 0;
2362   swig_callbackSignalDisconnected = 0;
2363 }
2364
2365 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2366   swig_init_callbacks();
2367 }
2368
2369 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2370
2371 }
2372
2373
2374 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2375   unsigned int c_result = SwigValueInit< unsigned int >() ;
2376   unsigned int jresult = 0 ;
2377
2378   if (!swig_callbackGetNumberOfItems) {
2379     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2380   } else {
2381     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2382     c_result = (unsigned int)jresult;
2383   }
2384   return c_result;
2385 }
2386
2387 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2388   Dali::Actor c_result ;
2389   void * jresult = 0 ;
2390   unsigned int jitemId  ;
2391
2392   if (!swig_callbackNewItem) {
2393     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2394   } else {
2395     jitemId = itemId;
2396     jresult = (void *) swig_callbackNewItem(jitemId);
2397     if (!jresult) {
2398       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2399       return c_result;
2400     }
2401     c_result = *(Dali::Actor *)jresult;
2402   }
2403   return c_result;
2404 }
2405
2406 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2407   unsigned int jitemId  ;
2408   void * jactor  ;
2409
2410   if (!swig_callbackItemReleased) {
2411     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2412     return;
2413   } else {
2414     jitemId = itemId;
2415     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2416     swig_callbackItemReleased(jitemId, jactor);
2417   }
2418 }
2419
2420 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2421   return Dali::Toolkit::ItemFactory::GetExtension();
2422 }
2423
2424 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2425   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2426   swig_callbackNewItem = callbackNewItem;
2427   swig_callbackItemReleased = callbackItemReleased;
2428 }
2429
2430 void SwigDirector_ItemFactory::swig_init_callbacks() {
2431   swig_callbackGetNumberOfItems = 0;
2432   swig_callbackNewItem = 0;
2433   swig_callbackItemReleased = 0;
2434 }
2435
2436 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2437   swig_init_callbacks();
2438 }
2439
2440 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2441
2442 }
2443
2444
2445 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2446   Dali::Actor c_result ;
2447   void * jresult = 0 ;
2448   void * jcurrent  ;
2449   void * jproposed  ;
2450   int jdirection  ;
2451
2452   if (!swig_callbackGetNextFocusableActor) {
2453     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2454   } else {
2455     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2456     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2457     jdirection = (int)direction;
2458     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2459     if (!jresult) {
2460       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2461       return c_result;
2462     }
2463     c_result = *(Dali::Actor *)jresult;
2464   }
2465   return c_result;
2466 }
2467
2468 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2469   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2470 }
2471
2472 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2473   swig_callbackGetNextFocusableActor = 0;
2474 }
2475
2476
2477 #ifdef __cplusplus
2478 extern "C" {
2479 #endif
2480
2481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2482   void * jresult ;
2483   floatp *result = 0 ;
2484
2485   {
2486     try {
2487       result = (floatp *)new_floatp();
2488     } catch (std::out_of_range& e) {
2489       {
2490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2491       };
2492     } catch (std::exception& e) {
2493       {
2494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2495       };
2496     } catch (...) {
2497       {
2498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2499       };
2500     }
2501   }
2502   jresult = (void *)result;
2503   return jresult;
2504 }
2505
2506
2507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2508   floatp *arg1 = (floatp *) 0 ;
2509
2510   arg1 = (floatp *)jarg1;
2511   {
2512     try {
2513       delete_floatp(arg1);
2514     } catch (std::out_of_range& e) {
2515       {
2516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2517       };
2518     } catch (std::exception& e) {
2519       {
2520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2521       };
2522     } catch (...) {
2523       {
2524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2525       };
2526     }
2527   }
2528 }
2529
2530
2531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2532   floatp *arg1 = (floatp *) 0 ;
2533   float arg2 ;
2534
2535   arg1 = (floatp *)jarg1;
2536   arg2 = (float)jarg2;
2537   {
2538     try {
2539       floatp_assign(arg1,arg2);
2540     } catch (std::out_of_range& e) {
2541       {
2542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2543       };
2544     } catch (std::exception& e) {
2545       {
2546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2547       };
2548     } catch (...) {
2549       {
2550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2551       };
2552     }
2553   }
2554 }
2555
2556
2557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2558   float jresult ;
2559   floatp *arg1 = (floatp *) 0 ;
2560   float result;
2561
2562   arg1 = (floatp *)jarg1;
2563   {
2564     try {
2565       result = (float)floatp_value(arg1);
2566     } catch (std::out_of_range& e) {
2567       {
2568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2569       };
2570     } catch (std::exception& e) {
2571       {
2572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2573       };
2574     } catch (...) {
2575       {
2576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2577       };
2578     }
2579   }
2580   jresult = result;
2581   return jresult;
2582 }
2583
2584
2585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2586   void * jresult ;
2587   floatp *arg1 = (floatp *) 0 ;
2588   float *result = 0 ;
2589
2590   arg1 = (floatp *)jarg1;
2591   {
2592     try {
2593       result = (float *)floatp_cast(arg1);
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2601       };
2602     } catch (...) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2605       };
2606     }
2607   }
2608   jresult = (void *)result;
2609   return jresult;
2610 }
2611
2612
2613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2614   void * jresult ;
2615   float *arg1 = (float *) 0 ;
2616   floatp *result = 0 ;
2617
2618   arg1 = (float *)jarg1;
2619   {
2620     try {
2621       result = (floatp *)floatp_frompointer(arg1);
2622     } catch (std::out_of_range& e) {
2623       {
2624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2625       };
2626     } catch (std::exception& e) {
2627       {
2628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2629       };
2630     } catch (...) {
2631       {
2632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2633       };
2634     }
2635   }
2636   jresult = (void *)result;
2637   return jresult;
2638 }
2639
2640
2641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2642   void * jresult ;
2643   intp *result = 0 ;
2644
2645   {
2646     try {
2647       result = (intp *)new_intp();
2648     } catch (std::out_of_range& e) {
2649       {
2650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2651       };
2652     } catch (std::exception& e) {
2653       {
2654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2659       };
2660     }
2661   }
2662   jresult = (void *)result;
2663   return jresult;
2664 }
2665
2666
2667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2668   intp *arg1 = (intp *) 0 ;
2669
2670   arg1 = (intp *)jarg1;
2671   {
2672     try {
2673       delete_intp(arg1);
2674     } catch (std::out_of_range& e) {
2675       {
2676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2677       };
2678     } catch (std::exception& e) {
2679       {
2680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2681       };
2682     } catch (...) {
2683       {
2684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2685       };
2686     }
2687   }
2688 }
2689
2690
2691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2692   intp *arg1 = (intp *) 0 ;
2693   int arg2 ;
2694
2695   arg1 = (intp *)jarg1;
2696   arg2 = (int)jarg2;
2697   {
2698     try {
2699       intp_assign(arg1,arg2);
2700     } catch (std::out_of_range& e) {
2701       {
2702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2703       };
2704     } catch (std::exception& e) {
2705       {
2706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2707       };
2708     } catch (...) {
2709       {
2710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2711       };
2712     }
2713   }
2714 }
2715
2716
2717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2718   int jresult ;
2719   intp *arg1 = (intp *) 0 ;
2720   int result;
2721
2722   arg1 = (intp *)jarg1;
2723   {
2724     try {
2725       result = (int)intp_value(arg1);
2726     } catch (std::out_of_range& e) {
2727       {
2728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2729       };
2730     } catch (std::exception& e) {
2731       {
2732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2733       };
2734     } catch (...) {
2735       {
2736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2737       };
2738     }
2739   }
2740   jresult = result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2746   void * jresult ;
2747   intp *arg1 = (intp *) 0 ;
2748   int *result = 0 ;
2749
2750   arg1 = (intp *)jarg1;
2751   {
2752     try {
2753       result = (int *)intp_cast(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (...) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2765       };
2766     }
2767   }
2768   jresult = (void *)result;
2769   return jresult;
2770 }
2771
2772
2773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2774   void * jresult ;
2775   int *arg1 = (int *) 0 ;
2776   intp *result = 0 ;
2777
2778   arg1 = (int *)jarg1;
2779   {
2780     try {
2781       result = (intp *)intp_frompointer(arg1);
2782     } catch (std::out_of_range& e) {
2783       {
2784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (std::exception& e) {
2787       {
2788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (...) {
2791       {
2792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2793       };
2794     }
2795   }
2796   jresult = (void *)result;
2797   return jresult;
2798 }
2799
2800
2801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2802   void * jresult ;
2803   doublep *result = 0 ;
2804
2805   {
2806     try {
2807       result = (doublep *)new_doublep();
2808     } catch (std::out_of_range& e) {
2809       {
2810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2811       };
2812     } catch (std::exception& e) {
2813       {
2814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2815       };
2816     } catch (...) {
2817       {
2818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2819       };
2820     }
2821   }
2822   jresult = (void *)result;
2823   return jresult;
2824 }
2825
2826
2827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2828   doublep *arg1 = (doublep *) 0 ;
2829
2830   arg1 = (doublep *)jarg1;
2831   {
2832     try {
2833       delete_doublep(arg1);
2834     } catch (std::out_of_range& e) {
2835       {
2836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2837       };
2838     } catch (std::exception& e) {
2839       {
2840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2841       };
2842     } catch (...) {
2843       {
2844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2845       };
2846     }
2847   }
2848 }
2849
2850
2851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2852   doublep *arg1 = (doublep *) 0 ;
2853   double arg2 ;
2854
2855   arg1 = (doublep *)jarg1;
2856   arg2 = (double)jarg2;
2857   {
2858     try {
2859       doublep_assign(arg1,arg2);
2860     } catch (std::out_of_range& e) {
2861       {
2862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2863       };
2864     } catch (std::exception& e) {
2865       {
2866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2867       };
2868     } catch (...) {
2869       {
2870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2871       };
2872     }
2873   }
2874 }
2875
2876
2877 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2878   double jresult ;
2879   doublep *arg1 = (doublep *) 0 ;
2880   double result;
2881
2882   arg1 = (doublep *)jarg1;
2883   {
2884     try {
2885       result = (double)doublep_value(arg1);
2886     } catch (std::out_of_range& e) {
2887       {
2888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2889       };
2890     } catch (std::exception& e) {
2891       {
2892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2893       };
2894     } catch (...) {
2895       {
2896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2897       };
2898     }
2899   }
2900   jresult = result;
2901   return jresult;
2902 }
2903
2904
2905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2906   void * jresult ;
2907   doublep *arg1 = (doublep *) 0 ;
2908   double *result = 0 ;
2909
2910   arg1 = (doublep *)jarg1;
2911   {
2912     try {
2913       result = (double *)doublep_cast(arg1);
2914     } catch (std::out_of_range& e) {
2915       {
2916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2917       };
2918     } catch (std::exception& e) {
2919       {
2920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2925       };
2926     }
2927   }
2928   jresult = (void *)result;
2929   return jresult;
2930 }
2931
2932
2933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2934   void * jresult ;
2935   double *arg1 = (double *) 0 ;
2936   doublep *result = 0 ;
2937
2938   arg1 = (double *)jarg1;
2939   {
2940     try {
2941       result = (doublep *)doublep_frompointer(arg1);
2942     } catch (std::out_of_range& e) {
2943       {
2944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2945       };
2946     } catch (std::exception& e) {
2947       {
2948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (...) {
2951       {
2952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2953       };
2954     }
2955   }
2956   jresult = (void *)result;
2957   return jresult;
2958 }
2959
2960
2961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2962   void * jresult ;
2963   uintp *result = 0 ;
2964
2965   {
2966     try {
2967       result = (uintp *)new_uintp();
2968     } catch (std::out_of_range& e) {
2969       {
2970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (std::exception& e) {
2973       {
2974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2975       };
2976     } catch (...) {
2977       {
2978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2979       };
2980     }
2981   }
2982   jresult = (void *)result;
2983   return jresult;
2984 }
2985
2986
2987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2988   uintp *arg1 = (uintp *) 0 ;
2989
2990   arg1 = (uintp *)jarg1;
2991   {
2992     try {
2993       delete_uintp(arg1);
2994     } catch (std::out_of_range& e) {
2995       {
2996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2997       };
2998     } catch (std::exception& e) {
2999       {
3000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3001       };
3002     } catch (...) {
3003       {
3004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3005       };
3006     }
3007   }
3008 }
3009
3010
3011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3012   uintp *arg1 = (uintp *) 0 ;
3013   unsigned int arg2 ;
3014
3015   arg1 = (uintp *)jarg1;
3016   arg2 = (unsigned int)jarg2;
3017   {
3018     try {
3019       uintp_assign(arg1,arg2);
3020     } catch (std::out_of_range& e) {
3021       {
3022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3023       };
3024     } catch (std::exception& e) {
3025       {
3026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3027       };
3028     } catch (...) {
3029       {
3030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3031       };
3032     }
3033   }
3034 }
3035
3036
3037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3038   unsigned int jresult ;
3039   uintp *arg1 = (uintp *) 0 ;
3040   unsigned int result;
3041
3042   arg1 = (uintp *)jarg1;
3043   {
3044     try {
3045       result = (unsigned int)uintp_value(arg1);
3046     } catch (std::out_of_range& e) {
3047       {
3048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3049       };
3050     } catch (std::exception& e) {
3051       {
3052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3053       };
3054     } catch (...) {
3055       {
3056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3057       };
3058     }
3059   }
3060   jresult = result;
3061   return jresult;
3062 }
3063
3064
3065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3066   void * jresult ;
3067   uintp *arg1 = (uintp *) 0 ;
3068   unsigned int *result = 0 ;
3069
3070   arg1 = (uintp *)jarg1;
3071   {
3072     try {
3073       result = (unsigned int *)uintp_cast(arg1);
3074     } catch (std::out_of_range& e) {
3075       {
3076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (std::exception& e) {
3079       {
3080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088   jresult = (void *)result;
3089   return jresult;
3090 }
3091
3092
3093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3094   void * jresult ;
3095   unsigned int *arg1 = (unsigned int *) 0 ;
3096   uintp *result = 0 ;
3097
3098   arg1 = (unsigned int *)jarg1;
3099   {
3100     try {
3101       result = (uintp *)uintp_frompointer(arg1);
3102     } catch (std::out_of_range& e) {
3103       {
3104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3105       };
3106     } catch (std::exception& e) {
3107       {
3108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3109       };
3110     } catch (...) {
3111       {
3112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3113       };
3114     }
3115   }
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3122   void * jresult ;
3123   ushortp *result = 0 ;
3124
3125   {
3126     try {
3127       result = (ushortp *)new_ushortp();
3128     } catch (std::out_of_range& e) {
3129       {
3130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3131       };
3132     } catch (std::exception& e) {
3133       {
3134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3135       };
3136     } catch (...) {
3137       {
3138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3139       };
3140     }
3141   }
3142   jresult = (void *)result;
3143   return jresult;
3144 }
3145
3146
3147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3148   ushortp *arg1 = (ushortp *) 0 ;
3149
3150   arg1 = (ushortp *)jarg1;
3151   {
3152     try {
3153       delete_ushortp(arg1);
3154     } catch (std::out_of_range& e) {
3155       {
3156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3157       };
3158     } catch (std::exception& e) {
3159       {
3160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3161       };
3162     } catch (...) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3165       };
3166     }
3167   }
3168 }
3169
3170
3171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3172   ushortp *arg1 = (ushortp *) 0 ;
3173   unsigned short arg2 ;
3174
3175   arg1 = (ushortp *)jarg1;
3176   arg2 = (unsigned short)jarg2;
3177   {
3178     try {
3179       ushortp_assign(arg1,arg2);
3180     } catch (std::out_of_range& e) {
3181       {
3182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3183       };
3184     } catch (std::exception& e) {
3185       {
3186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3187       };
3188     } catch (...) {
3189       {
3190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3191       };
3192     }
3193   }
3194 }
3195
3196
3197 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3198   unsigned short jresult ;
3199   ushortp *arg1 = (ushortp *) 0 ;
3200   unsigned short result;
3201
3202   arg1 = (ushortp *)jarg1;
3203   {
3204     try {
3205       result = (unsigned short)ushortp_value(arg1);
3206     } catch (std::out_of_range& e) {
3207       {
3208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3209       };
3210     } catch (std::exception& e) {
3211       {
3212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3213       };
3214     } catch (...) {
3215       {
3216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3217       };
3218     }
3219   }
3220   jresult = result;
3221   return jresult;
3222 }
3223
3224
3225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3226   void * jresult ;
3227   ushortp *arg1 = (ushortp *) 0 ;
3228   unsigned short *result = 0 ;
3229
3230   arg1 = (ushortp *)jarg1;
3231   {
3232     try {
3233       result = (unsigned short *)ushortp_cast(arg1);
3234     } catch (std::out_of_range& e) {
3235       {
3236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3237       };
3238     } catch (std::exception& e) {
3239       {
3240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3241       };
3242     } catch (...) {
3243       {
3244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3245       };
3246     }
3247   }
3248   jresult = (void *)result;
3249   return jresult;
3250 }
3251
3252
3253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3254   void * jresult ;
3255   unsigned short *arg1 = (unsigned short *) 0 ;
3256   ushortp *result = 0 ;
3257
3258   arg1 = (unsigned short *)jarg1;
3259   {
3260     try {
3261       result = (ushortp *)ushortp_frompointer(arg1);
3262     } catch (std::out_of_range& e) {
3263       {
3264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (std::exception& e) {
3267       {
3268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3273       };
3274     }
3275   }
3276   jresult = (void *)result;
3277   return jresult;
3278 }
3279
3280
3281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3282   unsigned int jresult ;
3283   int arg1 ;
3284   unsigned int result;
3285
3286   arg1 = (int)jarg1;
3287   {
3288     try {
3289       result = (unsigned int)int_to_uint(arg1);
3290     } catch (std::out_of_range& e) {
3291       {
3292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (std::exception& e) {
3295       {
3296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (...) {
3299       {
3300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3301       };
3302     }
3303   }
3304   jresult = result;
3305   return jresult;
3306 }
3307
3308
3309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3310   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3311
3312   arg1 = (Dali::RefObject *)jarg1;
3313   {
3314     try {
3315       (arg1)->Reference();
3316     } catch (std::out_of_range& e) {
3317       {
3318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3319       };
3320     } catch (std::exception& e) {
3321       {
3322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3323       };
3324     } catch (...) {
3325       {
3326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3327       };
3328     }
3329   }
3330 }
3331
3332
3333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3334   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3335
3336   arg1 = (Dali::RefObject *)jarg1;
3337   {
3338     try {
3339       (arg1)->Unreference();
3340     } catch (std::out_of_range& e) {
3341       {
3342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3343       };
3344     } catch (std::exception& e) {
3345       {
3346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3347       };
3348     } catch (...) {
3349       {
3350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3351       };
3352     }
3353   }
3354 }
3355
3356
3357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3358   int jresult ;
3359   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3360   int result;
3361
3362   arg1 = (Dali::RefObject *)jarg1;
3363   {
3364     try {
3365       result = (int)(arg1)->ReferenceCount();
3366     } catch (std::out_of_range& e) {
3367       {
3368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3369       };
3370     } catch (std::exception& e) {
3371       {
3372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3373       };
3374     } catch (...) {
3375       {
3376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3377       };
3378     }
3379   }
3380   jresult = result;
3381   return jresult;
3382 }
3383
3384
3385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3386   void * jresult ;
3387   Dali::Any *result = 0 ;
3388
3389   {
3390     try {
3391       result = (Dali::Any *)new Dali::Any();
3392     } catch (std::out_of_range& e) {
3393       {
3394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3395       };
3396     } catch (std::exception& e) {
3397       {
3398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3403       };
3404     }
3405   }
3406   jresult = (void *)result;
3407   return jresult;
3408 }
3409
3410
3411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3412   Dali::Any *arg1 = (Dali::Any *) 0 ;
3413
3414   arg1 = (Dali::Any *)jarg1;
3415   {
3416     try {
3417       delete arg1;
3418     } catch (std::out_of_range& e) {
3419       {
3420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3421       };
3422     } catch (std::exception& e) {
3423       {
3424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3425       };
3426     } catch (...) {
3427       {
3428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3429       };
3430     }
3431   }
3432 }
3433
3434
3435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3436   char *arg1 = (char *) 0 ;
3437
3438   arg1 = (char *)jarg1;
3439   {
3440     try {
3441       Dali::Any::AssertAlways((char const *)arg1);
3442     } catch (std::out_of_range& e) {
3443       {
3444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3445       };
3446     } catch (std::exception& e) {
3447       {
3448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3449       };
3450     } catch (...) {
3451       {
3452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3453       };
3454     }
3455   }
3456 }
3457
3458
3459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3460   void * jresult ;
3461   Dali::Any *arg1 = 0 ;
3462   Dali::Any *result = 0 ;
3463
3464   arg1 = (Dali::Any *)jarg1;
3465   if (!arg1) {
3466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3467     return 0;
3468   }
3469   {
3470     try {
3471       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3472     } catch (std::out_of_range& e) {
3473       {
3474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3475       };
3476     } catch (std::exception& e) {
3477       {
3478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3479       };
3480     } catch (...) {
3481       {
3482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3483       };
3484     }
3485   }
3486   jresult = (void *)result;
3487   return jresult;
3488 }
3489
3490
3491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3492   void * jresult ;
3493   Dali::Any *arg1 = (Dali::Any *) 0 ;
3494   Dali::Any *arg2 = 0 ;
3495   Dali::Any *result = 0 ;
3496
3497   arg1 = (Dali::Any *)jarg1;
3498   arg2 = (Dali::Any *)jarg2;
3499   if (!arg2) {
3500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3501     return 0;
3502   }
3503   {
3504     try {
3505       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3506     } catch (std::out_of_range& e) {
3507       {
3508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3509       };
3510     } catch (std::exception& e) {
3511       {
3512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3513       };
3514     } catch (...) {
3515       {
3516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3517       };
3518     }
3519   }
3520   jresult = (void *)result;
3521   return jresult;
3522 }
3523
3524
3525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3526   void * jresult ;
3527   Dali::Any *arg1 = (Dali::Any *) 0 ;
3528   std::type_info *result = 0 ;
3529
3530   arg1 = (Dali::Any *)jarg1;
3531   {
3532     try {
3533       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3534     } catch (std::out_of_range& e) {
3535       {
3536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3537       };
3538     } catch (std::exception& e) {
3539       {
3540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3541       };
3542     } catch (...) {
3543       {
3544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3545       };
3546     }
3547   }
3548   jresult = (void *)result;
3549   return jresult;
3550 }
3551
3552
3553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3554   unsigned int jresult ;
3555   Dali::Any *arg1 = (Dali::Any *) 0 ;
3556   bool result;
3557
3558   arg1 = (Dali::Any *)jarg1;
3559   {
3560     try {
3561       result = (bool)((Dali::Any const *)arg1)->Empty();
3562     } catch (std::out_of_range& e) {
3563       {
3564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3565       };
3566     } catch (std::exception& e) {
3567       {
3568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3569       };
3570     } catch (...) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3573       };
3574     }
3575   }
3576   jresult = result;
3577   return jresult;
3578 }
3579
3580
3581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3582   void * jresult ;
3583   std::type_info *arg1 = 0 ;
3584   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3585   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3586   Dali::Any::AnyContainerBase *result = 0 ;
3587
3588   arg1 = (std::type_info *)jarg1;
3589   if (!arg1) {
3590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3591     return 0;
3592   }
3593   arg2 = (Dali::Any::CloneFunc)jarg2;
3594   arg3 = (Dali::Any::DeleteFunc)jarg3;
3595   {
3596     try {
3597       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3598     } catch (std::out_of_range& e) {
3599       {
3600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3601       };
3602     } catch (std::exception& e) {
3603       {
3604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3605       };
3606     } catch (...) {
3607       {
3608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3609       };
3610     }
3611   }
3612   jresult = (void *)result;
3613   return jresult;
3614 }
3615
3616
3617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3618   void * jresult ;
3619   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3620   std::type_info *result = 0 ;
3621
3622   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3623   {
3624     try {
3625       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
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 (...) {
3635       {
3636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3637       };
3638     }
3639   }
3640   jresult = (void *)result;
3641   return jresult;
3642 }
3643
3644
3645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3646   void * jresult ;
3647   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3648   ::std::type_info *result = 0 ;
3649
3650   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3651   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3652   jresult = (void *)result;
3653   return jresult;
3654 }
3655
3656
3657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3658   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3659   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3660
3661   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3662   arg2 = (Dali::Any::CloneFunc)jarg2;
3663   if (arg1) (arg1)->mCloneFunc = arg2;
3664 }
3665
3666
3667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3668   void * jresult ;
3669   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3670   Dali::Any::CloneFunc result;
3671
3672   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3673   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3680   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3681   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3682
3683   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3684   arg2 = (Dali::Any::DeleteFunc)jarg2;
3685   if (arg1) (arg1)->mDeleteFunc = arg2;
3686 }
3687
3688
3689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3690   void * jresult ;
3691   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3692   Dali::Any::DeleteFunc result;
3693
3694   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3695   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3696   jresult = (void *)result;
3697   return jresult;
3698 }
3699
3700
3701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3702   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3703
3704   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3705   {
3706     try {
3707       delete arg1;
3708     } catch (std::out_of_range& e) {
3709       {
3710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3711       };
3712     } catch (std::exception& e) {
3713       {
3714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3715       };
3716     } catch (...) {
3717       {
3718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3719       };
3720     }
3721   }
3722 }
3723
3724
3725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3726   Dali::Any *arg1 = (Dali::Any *) 0 ;
3727   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3728
3729   arg1 = (Dali::Any *)jarg1;
3730   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3731   if (arg1) (arg1)->mContainer = arg2;
3732 }
3733
3734
3735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3736   void * jresult ;
3737   Dali::Any *arg1 = (Dali::Any *) 0 ;
3738   Dali::Any::AnyContainerBase *result = 0 ;
3739
3740   arg1 = (Dali::Any *)jarg1;
3741   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3742   jresult = (void *)result;
3743   return jresult;
3744 }
3745
3746
3747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3748   char *arg1 = (char *) 0 ;
3749   char *arg2 = (char *) 0 ;
3750
3751   arg1 = (char *)jarg1;
3752   arg2 = (char *)jarg2;
3753   {
3754     try {
3755       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3756     } catch (std::out_of_range& e) {
3757       {
3758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3759       };
3760     } catch (std::exception& e) {
3761       {
3762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3763       };
3764     } catch (...) {
3765       {
3766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3767       };
3768     }
3769   }
3770 }
3771
3772
3773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3774   void * jresult ;
3775   char *arg1 = (char *) 0 ;
3776   char *arg2 = (char *) 0 ;
3777   Dali::DaliException *result = 0 ;
3778
3779   arg1 = (char *)jarg1;
3780   arg2 = (char *)jarg2;
3781   {
3782     try {
3783       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3784     } catch (std::out_of_range& e) {
3785       {
3786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3787       };
3788     } catch (std::exception& e) {
3789       {
3790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3791       };
3792     } catch (...) {
3793       {
3794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3795       };
3796     }
3797   }
3798   jresult = (void *)result;
3799   return jresult;
3800 }
3801
3802
3803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3804   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3805   char *arg2 = (char *) 0 ;
3806
3807   arg1 = (Dali::DaliException *)jarg1;
3808   arg2 = (char *)jarg2;
3809   {
3810     if (arg2) {
3811       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3812       strcpy((char *)arg1->location, (const char *)arg2);
3813     } else {
3814       arg1->location = 0;
3815     }
3816   }
3817 }
3818
3819
3820 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3821   char * jresult ;
3822   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3823   char *result = 0 ;
3824
3825   arg1 = (Dali::DaliException *)jarg1;
3826   result = (char *) ((arg1)->location);
3827   jresult = SWIG_csharp_string_callback((const char *)result);
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3833   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3834   char *arg2 = (char *) 0 ;
3835
3836   arg1 = (Dali::DaliException *)jarg1;
3837   arg2 = (char *)jarg2;
3838   {
3839     if (arg2) {
3840       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3841       strcpy((char *)arg1->condition, (const char *)arg2);
3842     } else {
3843       arg1->condition = 0;
3844     }
3845   }
3846 }
3847
3848
3849 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3850   char * jresult ;
3851   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3852   char *result = 0 ;
3853
3854   arg1 = (Dali::DaliException *)jarg1;
3855   result = (char *) ((arg1)->condition);
3856   jresult = SWIG_csharp_string_callback((const char *)result);
3857   return jresult;
3858 }
3859
3860
3861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3862   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3863
3864   arg1 = (Dali::DaliException *)jarg1;
3865   {
3866     try {
3867       delete arg1;
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3875       };
3876     } catch (...) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3879       };
3880     }
3881   }
3882 }
3883
3884
3885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3886   void * jresult ;
3887   Dali::Vector2 *result = 0 ;
3888
3889   {
3890     try {
3891       result = (Dali::Vector2 *)new Dali::Vector2();
3892     } catch (std::out_of_range& e) {
3893       {
3894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3895       };
3896     } catch (std::exception& e) {
3897       {
3898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3899       };
3900     } catch (...) {
3901       {
3902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3903       };
3904     }
3905   }
3906   jresult = (void *)result;
3907   return jresult;
3908 }
3909
3910
3911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3912   void * jresult ;
3913   float arg1 ;
3914   float arg2 ;
3915   Dali::Vector2 *result = 0 ;
3916
3917   arg1 = (float)jarg1;
3918   arg2 = (float)jarg2;
3919   {
3920     try {
3921       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3922     } catch (std::out_of_range& e) {
3923       {
3924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3925       };
3926     } catch (std::exception& e) {
3927       {
3928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3929       };
3930     } catch (...) {
3931       {
3932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3933       };
3934     }
3935   }
3936   jresult = (void *)result;
3937   return jresult;
3938 }
3939
3940
3941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3942   void * jresult ;
3943   float *arg1 = (float *) 0 ;
3944   Dali::Vector2 *result = 0 ;
3945
3946   arg1 = jarg1;
3947   {
3948     try {
3949       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3950     } catch (std::out_of_range& e) {
3951       {
3952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3953       };
3954     } catch (std::exception& e) {
3955       {
3956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3957       };
3958     } catch (...) {
3959       {
3960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3961       };
3962     }
3963   }
3964   jresult = (void *)result;
3965
3966
3967   return jresult;
3968 }
3969
3970
3971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3972   void * jresult ;
3973   Dali::Vector3 *arg1 = 0 ;
3974   Dali::Vector2 *result = 0 ;
3975
3976   arg1 = (Dali::Vector3 *)jarg1;
3977   if (!arg1) {
3978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3979     return 0;
3980   }
3981   {
3982     try {
3983       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3984     } catch (std::out_of_range& e) {
3985       {
3986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3987       };
3988     } catch (std::exception& e) {
3989       {
3990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3991       };
3992     } catch (...) {
3993       {
3994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3995       };
3996     }
3997   }
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4004   void * jresult ;
4005   Dali::Vector4 *arg1 = 0 ;
4006   Dali::Vector2 *result = 0 ;
4007
4008   arg1 = (Dali::Vector4 *)jarg1;
4009   if (!arg1) {
4010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4011     return 0;
4012   }
4013   {
4014     try {
4015       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4016     } catch (std::out_of_range& e) {
4017       {
4018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4019       };
4020     } catch (std::exception& e) {
4021       {
4022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4023       };
4024     } catch (...) {
4025       {
4026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4027       };
4028     }
4029   }
4030   jresult = (void *)result;
4031   return jresult;
4032 }
4033
4034
4035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4036   void * jresult ;
4037   Dali::Vector2 *result = 0 ;
4038
4039   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4040   jresult = (void *)result;
4041   return jresult;
4042 }
4043
4044
4045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4046   void * jresult ;
4047   Dali::Vector2 *result = 0 ;
4048
4049   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4050   jresult = (void *)result;
4051   return jresult;
4052 }
4053
4054
4055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4056   void * jresult ;
4057   Dali::Vector2 *result = 0 ;
4058
4059   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4060   jresult = (void *)result;
4061   return jresult;
4062 }
4063
4064
4065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4066   void * jresult ;
4067   Dali::Vector2 *result = 0 ;
4068
4069   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4070   jresult = (void *)result;
4071   return jresult;
4072 }
4073
4074
4075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4076   void * jresult ;
4077   Dali::Vector2 *result = 0 ;
4078
4079   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4080   jresult = (void *)result;
4081   return jresult;
4082 }
4083
4084
4085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4086   void * jresult ;
4087   Dali::Vector2 *result = 0 ;
4088
4089   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4090   jresult = (void *)result;
4091   return jresult;
4092 }
4093
4094
4095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4096   void * jresult ;
4097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4098   float *arg2 = (float *) 0 ;
4099   Dali::Vector2 *result = 0 ;
4100
4101   arg1 = (Dali::Vector2 *)jarg1;
4102   arg2 = jarg2;
4103   {
4104     try {
4105       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4106     } catch (std::out_of_range& e) {
4107       {
4108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4109       };
4110     } catch (std::exception& e) {
4111       {
4112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (...) {
4115       {
4116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4117       };
4118     }
4119   }
4120   jresult = (void *)result;
4121
4122
4123   return jresult;
4124 }
4125
4126
4127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4128   void * jresult ;
4129   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4130   Dali::Vector3 *arg2 = 0 ;
4131   Dali::Vector2 *result = 0 ;
4132
4133   arg1 = (Dali::Vector2 *)jarg1;
4134   arg2 = (Dali::Vector3 *)jarg2;
4135   if (!arg2) {
4136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4137     return 0;
4138   }
4139   {
4140     try {
4141       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4142     } catch (std::out_of_range& e) {
4143       {
4144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4145       };
4146     } catch (std::exception& e) {
4147       {
4148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4149       };
4150     } catch (...) {
4151       {
4152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4153       };
4154     }
4155   }
4156   jresult = (void *)result;
4157   return jresult;
4158 }
4159
4160
4161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4162   void * jresult ;
4163   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4164   Dali::Vector4 *arg2 = 0 ;
4165   Dali::Vector2 *result = 0 ;
4166
4167   arg1 = (Dali::Vector2 *)jarg1;
4168   arg2 = (Dali::Vector4 *)jarg2;
4169   if (!arg2) {
4170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4171     return 0;
4172   }
4173   {
4174     try {
4175       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4176     } catch (std::out_of_range& e) {
4177       {
4178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4179       };
4180     } catch (std::exception& e) {
4181       {
4182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4183       };
4184     } catch (...) {
4185       {
4186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4187       };
4188     }
4189   }
4190   jresult = (void *)result;
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4196   void * jresult ;
4197   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4198   Dali::Vector2 *arg2 = 0 ;
4199   Dali::Vector2 result;
4200
4201   arg1 = (Dali::Vector2 *)jarg1;
4202   arg2 = (Dali::Vector2 *)jarg2;
4203   if (!arg2) {
4204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4205     return 0;
4206   }
4207   {
4208     try {
4209       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4210     } catch (std::out_of_range& e) {
4211       {
4212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4213       };
4214     } catch (std::exception& e) {
4215       {
4216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4217       };
4218     } catch (...) {
4219       {
4220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4221       };
4222     }
4223   }
4224   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4225   return jresult;
4226 }
4227
4228
4229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4230   void * jresult ;
4231   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4232   Dali::Vector2 *arg2 = 0 ;
4233   Dali::Vector2 *result = 0 ;
4234
4235   arg1 = (Dali::Vector2 *)jarg1;
4236   arg2 = (Dali::Vector2 *)jarg2;
4237   if (!arg2) {
4238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4239     return 0;
4240   }
4241   {
4242     try {
4243       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4244     } catch (std::out_of_range& e) {
4245       {
4246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4247       };
4248     } catch (std::exception& e) {
4249       {
4250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4251       };
4252     } catch (...) {
4253       {
4254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4255       };
4256     }
4257   }
4258   jresult = (void *)result;
4259   return jresult;
4260 }
4261
4262
4263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4264   void * jresult ;
4265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4266   Dali::Vector2 *arg2 = 0 ;
4267   Dali::Vector2 result;
4268
4269   arg1 = (Dali::Vector2 *)jarg1;
4270   arg2 = (Dali::Vector2 *)jarg2;
4271   if (!arg2) {
4272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4273     return 0;
4274   }
4275   {
4276     try {
4277       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4278     } catch (std::out_of_range& e) {
4279       {
4280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4281       };
4282     } catch (std::exception& e) {
4283       {
4284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4285       };
4286     } catch (...) {
4287       {
4288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4289       };
4290     }
4291   }
4292   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4293   return jresult;
4294 }
4295
4296
4297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4298   void * jresult ;
4299   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4300   Dali::Vector2 *arg2 = 0 ;
4301   Dali::Vector2 *result = 0 ;
4302
4303   arg1 = (Dali::Vector2 *)jarg1;
4304   arg2 = (Dali::Vector2 *)jarg2;
4305   if (!arg2) {
4306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4307     return 0;
4308   }
4309   {
4310     try {
4311       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4312     } catch (std::out_of_range& e) {
4313       {
4314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4315       };
4316     } catch (std::exception& e) {
4317       {
4318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4319       };
4320     } catch (...) {
4321       {
4322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4323       };
4324     }
4325   }
4326   jresult = (void *)result;
4327   return jresult;
4328 }
4329
4330
4331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4332   void * jresult ;
4333   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4334   Dali::Vector2 *arg2 = 0 ;
4335   Dali::Vector2 result;
4336
4337   arg1 = (Dali::Vector2 *)jarg1;
4338   arg2 = (Dali::Vector2 *)jarg2;
4339   if (!arg2) {
4340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4341     return 0;
4342   }
4343   {
4344     try {
4345       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4346     } catch (std::out_of_range& e) {
4347       {
4348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4349       };
4350     } catch (std::exception& e) {
4351       {
4352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4353       };
4354     } catch (...) {
4355       {
4356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4357       };
4358     }
4359   }
4360   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4361   return jresult;
4362 }
4363
4364
4365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4366   void * jresult ;
4367   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4368   float arg2 ;
4369   Dali::Vector2 result;
4370
4371   arg1 = (Dali::Vector2 *)jarg1;
4372   arg2 = (float)jarg2;
4373   {
4374     try {
4375       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4376     } catch (std::out_of_range& e) {
4377       {
4378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (std::exception& e) {
4381       {
4382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4396   void * jresult ;
4397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4398   Dali::Vector2 *arg2 = 0 ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   arg1 = (Dali::Vector2 *)jarg1;
4402   arg2 = (Dali::Vector2 *)jarg2;
4403   if (!arg2) {
4404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4405     return 0;
4406   }
4407   {
4408     try {
4409       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 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 (...) {
4419       {
4420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4421       };
4422     }
4423   }
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4430   void * jresult ;
4431   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4432   float arg2 ;
4433   Dali::Vector2 *result = 0 ;
4434
4435   arg1 = (Dali::Vector2 *)jarg1;
4436   arg2 = (float)jarg2;
4437   {
4438     try {
4439       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4440     } catch (std::out_of_range& e) {
4441       {
4442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4443       };
4444     } catch (std::exception& e) {
4445       {
4446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4447       };
4448     } catch (...) {
4449       {
4450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4451       };
4452     }
4453   }
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   Dali::Vector2 *arg2 = 0 ;
4463   Dali::Vector2 result;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = (Dali::Vector2 *)jarg2;
4467   if (!arg2) {
4468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4469     return 0;
4470   }
4471   {
4472     try {
4473       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4474     } catch (std::out_of_range& e) {
4475       {
4476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (std::exception& e) {
4479       {
4480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4489   return jresult;
4490 }
4491
4492
4493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4494   void * jresult ;
4495   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4496   float arg2 ;
4497   Dali::Vector2 result;
4498
4499   arg1 = (Dali::Vector2 *)jarg1;
4500   arg2 = (float)jarg2;
4501   {
4502     try {
4503       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4504     } catch (std::out_of_range& e) {
4505       {
4506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4507       };
4508     } catch (std::exception& e) {
4509       {
4510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4511       };
4512     } catch (...) {
4513       {
4514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4515       };
4516     }
4517   }
4518   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4519   return jresult;
4520 }
4521
4522
4523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4524   void * jresult ;
4525   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4526   Dali::Vector2 *arg2 = 0 ;
4527   Dali::Vector2 *result = 0 ;
4528
4529   arg1 = (Dali::Vector2 *)jarg1;
4530   arg2 = (Dali::Vector2 *)jarg2;
4531   if (!arg2) {
4532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4533     return 0;
4534   }
4535   {
4536     try {
4537       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4538     } catch (std::out_of_range& e) {
4539       {
4540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4541       };
4542     } catch (std::exception& e) {
4543       {
4544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (...) {
4547       {
4548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4549       };
4550     }
4551   }
4552   jresult = (void *)result;
4553   return jresult;
4554 }
4555
4556
4557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4558   void * jresult ;
4559   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4560   float arg2 ;
4561   Dali::Vector2 *result = 0 ;
4562
4563   arg1 = (Dali::Vector2 *)jarg1;
4564   arg2 = (float)jarg2;
4565   {
4566     try {
4567       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4568     } catch (std::out_of_range& e) {
4569       {
4570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4571       };
4572     } catch (std::exception& e) {
4573       {
4574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4575       };
4576     } catch (...) {
4577       {
4578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4579       };
4580     }
4581   }
4582   jresult = (void *)result;
4583   return jresult;
4584 }
4585
4586
4587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4588   void * jresult ;
4589   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4590   Dali::Vector2 result;
4591
4592   arg1 = (Dali::Vector2 *)jarg1;
4593   {
4594     try {
4595       result = ((Dali::Vector2 const *)arg1)->operator -();
4596     } catch (std::out_of_range& e) {
4597       {
4598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4599       };
4600     } catch (std::exception& e) {
4601       {
4602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4603       };
4604     } catch (...) {
4605       {
4606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4607       };
4608     }
4609   }
4610   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4611   return jresult;
4612 }
4613
4614
4615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4616   unsigned int jresult ;
4617   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4618   Dali::Vector2 *arg2 = 0 ;
4619   bool result;
4620
4621   arg1 = (Dali::Vector2 *)jarg1;
4622   arg2 = (Dali::Vector2 *)jarg2;
4623   if (!arg2) {
4624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4625     return 0;
4626   }
4627   {
4628     try {
4629       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4630     } catch (std::out_of_range& e) {
4631       {
4632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4633       };
4634     } catch (std::exception& e) {
4635       {
4636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4637       };
4638     } catch (...) {
4639       {
4640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4641       };
4642     }
4643   }
4644   jresult = result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4650   unsigned int jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   Dali::Vector2 *arg2 = 0 ;
4653   bool result;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   arg2 = (Dali::Vector2 *)jarg2;
4657   if (!arg2) {
4658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4659     return 0;
4660   }
4661   {
4662     try {
4663       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4664     } catch (std::out_of_range& e) {
4665       {
4666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4667       };
4668     } catch (std::exception& e) {
4669       {
4670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (...) {
4673       {
4674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4675       };
4676     }
4677   }
4678   jresult = result;
4679   return jresult;
4680 }
4681
4682
4683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4684   float jresult ;
4685   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4686   unsigned int arg2 ;
4687   float *result = 0 ;
4688
4689   arg1 = (Dali::Vector2 *)jarg1;
4690   arg2 = (unsigned int)jarg2;
4691   {
4692     try {
4693       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4694     } catch (std::out_of_range& e) {
4695       {
4696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4697       };
4698     } catch (std::exception& e) {
4699       {
4700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (...) {
4703       {
4704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4705       };
4706     }
4707   }
4708   jresult = *result;
4709   return jresult;
4710 }
4711
4712
4713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4714   float jresult ;
4715   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4716   float result;
4717
4718   arg1 = (Dali::Vector2 *)jarg1;
4719   {
4720     try {
4721       result = (float)((Dali::Vector2 const *)arg1)->Length();
4722     } catch (std::out_of_range& e) {
4723       {
4724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4725       };
4726     } catch (std::exception& e) {
4727       {
4728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4729       };
4730     } catch (...) {
4731       {
4732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4733       };
4734     }
4735   }
4736   jresult = result;
4737   return jresult;
4738 }
4739
4740
4741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4742   float jresult ;
4743   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4744   float result;
4745
4746   arg1 = (Dali::Vector2 *)jarg1;
4747   {
4748     try {
4749       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4750     } catch (std::out_of_range& e) {
4751       {
4752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4753       };
4754     } catch (std::exception& e) {
4755       {
4756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4757       };
4758     } catch (...) {
4759       {
4760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4761       };
4762     }
4763   }
4764   jresult = result;
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4770   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   {
4774     try {
4775       (arg1)->Normalize();
4776     } catch (std::out_of_range& e) {
4777       {
4778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4779       };
4780     } catch (std::exception& e) {
4781       {
4782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4787       };
4788     }
4789   }
4790 }
4791
4792
4793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4794   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4795   Dali::Vector2 *arg2 = 0 ;
4796   Dali::Vector2 *arg3 = 0 ;
4797
4798   arg1 = (Dali::Vector2 *)jarg1;
4799   arg2 = (Dali::Vector2 *)jarg2;
4800   if (!arg2) {
4801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4802     return ;
4803   }
4804   arg3 = (Dali::Vector2 *)jarg3;
4805   if (!arg3) {
4806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4807     return ;
4808   }
4809   {
4810     try {
4811       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4812     } catch (std::out_of_range& e) {
4813       {
4814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4815       };
4816     } catch (std::exception& e) {
4817       {
4818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4819       };
4820     } catch (...) {
4821       {
4822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4823       };
4824     }
4825   }
4826 }
4827
4828
4829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4830   void * jresult ;
4831   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4832   float *result = 0 ;
4833
4834   arg1 = (Dali::Vector2 *)jarg1;
4835   {
4836     try {
4837       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4838     } catch (std::out_of_range& e) {
4839       {
4840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4841       };
4842     } catch (std::exception& e) {
4843       {
4844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4845       };
4846     } catch (...) {
4847       {
4848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4849       };
4850     }
4851   }
4852   jresult = (void *)result;
4853   return jresult;
4854 }
4855
4856
4857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4858   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4859   float arg2 ;
4860
4861   arg1 = (Dali::Vector2 *)jarg1;
4862   arg2 = (float)jarg2;
4863   if (arg1) (arg1)->x = arg2;
4864 }
4865
4866
4867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4868   float jresult ;
4869   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4870   float result;
4871
4872   arg1 = (Dali::Vector2 *)jarg1;
4873   result = (float) ((arg1)->x);
4874   jresult = result;
4875   return jresult;
4876 }
4877
4878
4879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   float arg2 ;
4882
4883   arg1 = (Dali::Vector2 *)jarg1;
4884   arg2 = (float)jarg2;
4885   if (arg1) (arg1)->width = arg2;
4886 }
4887
4888
4889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4890   float jresult ;
4891   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4892   float result;
4893
4894   arg1 = (Dali::Vector2 *)jarg1;
4895   result = (float) ((arg1)->width);
4896   jresult = result;
4897   return jresult;
4898 }
4899
4900
4901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4902   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4903   float arg2 ;
4904
4905   arg1 = (Dali::Vector2 *)jarg1;
4906   arg2 = (float)jarg2;
4907   if (arg1) (arg1)->y = arg2;
4908 }
4909
4910
4911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4912   float jresult ;
4913   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4914   float result;
4915
4916   arg1 = (Dali::Vector2 *)jarg1;
4917   result = (float) ((arg1)->y);
4918   jresult = result;
4919   return jresult;
4920 }
4921
4922
4923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4924   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4925   float arg2 ;
4926
4927   arg1 = (Dali::Vector2 *)jarg1;
4928   arg2 = (float)jarg2;
4929   if (arg1) (arg1)->height = arg2;
4930 }
4931
4932
4933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4934   float jresult ;
4935   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4936   float result;
4937
4938   arg1 = (Dali::Vector2 *)jarg1;
4939   result = (float) ((arg1)->height);
4940   jresult = result;
4941   return jresult;
4942 }
4943
4944
4945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4946   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4947
4948   arg1 = (Dali::Vector2 *)jarg1;
4949   {
4950     try {
4951       delete arg1;
4952     } catch (std::out_of_range& e) {
4953       {
4954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4955       };
4956     } catch (std::exception& e) {
4957       {
4958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4959       };
4960     } catch (...) {
4961       {
4962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4963       };
4964     }
4965   }
4966 }
4967
4968
4969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4970   void * jresult ;
4971   Dali::Vector2 *arg1 = 0 ;
4972   Dali::Vector2 *arg2 = 0 ;
4973   Dali::Vector2 result;
4974
4975   arg1 = (Dali::Vector2 *)jarg1;
4976   if (!arg1) {
4977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4978     return 0;
4979   }
4980   arg2 = (Dali::Vector2 *)jarg2;
4981   if (!arg2) {
4982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4983     return 0;
4984   }
4985   {
4986     try {
4987       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4988     } catch (std::out_of_range& e) {
4989       {
4990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4991       };
4992     } catch (std::exception& e) {
4993       {
4994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4995       };
4996     } catch (...) {
4997       {
4998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4999       };
5000     }
5001   }
5002   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5003   return jresult;
5004 }
5005
5006
5007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5008   void * jresult ;
5009   Dali::Vector2 *arg1 = 0 ;
5010   Dali::Vector2 *arg2 = 0 ;
5011   Dali::Vector2 result;
5012
5013   arg1 = (Dali::Vector2 *)jarg1;
5014   if (!arg1) {
5015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5016     return 0;
5017   }
5018   arg2 = (Dali::Vector2 *)jarg2;
5019   if (!arg2) {
5020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5021     return 0;
5022   }
5023   {
5024     try {
5025       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5026     } catch (std::out_of_range& e) {
5027       {
5028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (std::exception& e) {
5031       {
5032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (...) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5037       };
5038     }
5039   }
5040   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5041   return jresult;
5042 }
5043
5044
5045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5046   void * jresult ;
5047   Dali::Vector2 *arg1 = 0 ;
5048   float *arg2 = 0 ;
5049   float *arg3 = 0 ;
5050   float temp2 ;
5051   float temp3 ;
5052   Dali::Vector2 result;
5053
5054   arg1 = (Dali::Vector2 *)jarg1;
5055   if (!arg1) {
5056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5057     return 0;
5058   }
5059   temp2 = (float)jarg2;
5060   arg2 = &temp2;
5061   temp3 = (float)jarg3;
5062   arg3 = &temp3;
5063   {
5064     try {
5065       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5066     } catch (std::out_of_range& e) {
5067       {
5068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (std::exception& e) {
5071       {
5072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (...) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5077       };
5078     }
5079   }
5080   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5081   return jresult;
5082 }
5083
5084
5085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5086   void * jresult ;
5087   Dali::Vector3 *result = 0 ;
5088
5089   {
5090     try {
5091       result = (Dali::Vector3 *)new Dali::Vector3();
5092     } catch (std::out_of_range& e) {
5093       {
5094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5095       };
5096     } catch (std::exception& e) {
5097       {
5098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5099       };
5100     } catch (...) {
5101       {
5102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5103       };
5104     }
5105   }
5106   jresult = (void *)result;
5107   return jresult;
5108 }
5109
5110
5111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5112   void * jresult ;
5113   float arg1 ;
5114   float arg2 ;
5115   float arg3 ;
5116   Dali::Vector3 *result = 0 ;
5117
5118   arg1 = (float)jarg1;
5119   arg2 = (float)jarg2;
5120   arg3 = (float)jarg3;
5121   {
5122     try {
5123       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5124     } catch (std::out_of_range& e) {
5125       {
5126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5127       };
5128     } catch (std::exception& e) {
5129       {
5130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5131       };
5132     } catch (...) {
5133       {
5134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5135       };
5136     }
5137   }
5138   jresult = (void *)result;
5139   return jresult;
5140 }
5141
5142
5143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5144   void * jresult ;
5145   float *arg1 = (float *) 0 ;
5146   Dali::Vector3 *result = 0 ;
5147
5148   arg1 = jarg1;
5149   {
5150     try {
5151       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5152     } catch (std::out_of_range& e) {
5153       {
5154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (std::exception& e) {
5157       {
5158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166   jresult = (void *)result;
5167
5168
5169   return jresult;
5170 }
5171
5172
5173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5174   void * jresult ;
5175   Dali::Vector2 *arg1 = 0 ;
5176   Dali::Vector3 *result = 0 ;
5177
5178   arg1 = (Dali::Vector2 *)jarg1;
5179   if (!arg1) {
5180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5181     return 0;
5182   }
5183   {
5184     try {
5185       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5186     } catch (std::out_of_range& e) {
5187       {
5188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5189       };
5190     } catch (std::exception& e) {
5191       {
5192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5193       };
5194     } catch (...) {
5195       {
5196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5197       };
5198     }
5199   }
5200   jresult = (void *)result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5206   void * jresult ;
5207   Dali::Vector4 *arg1 = 0 ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   arg1 = (Dali::Vector4 *)jarg1;
5211   if (!arg1) {
5212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5213     return 0;
5214   }
5215   {
5216     try {
5217       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5218     } catch (std::out_of_range& e) {
5219       {
5220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (std::exception& e) {
5223       {
5224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232   jresult = (void *)result;
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5238   void * jresult ;
5239   Dali::Vector3 *result = 0 ;
5240
5241   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5242   jresult = (void *)result;
5243   return jresult;
5244 }
5245
5246
5247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5248   void * jresult ;
5249   Dali::Vector3 *result = 0 ;
5250
5251   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5252   jresult = (void *)result;
5253   return jresult;
5254 }
5255
5256
5257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5258   void * jresult ;
5259   Dali::Vector3 *result = 0 ;
5260
5261   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5262   jresult = (void *)result;
5263   return jresult;
5264 }
5265
5266
5267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5268   void * jresult ;
5269   Dali::Vector3 *result = 0 ;
5270
5271   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5272   jresult = (void *)result;
5273   return jresult;
5274 }
5275
5276
5277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5278   void * jresult ;
5279   Dali::Vector3 *result = 0 ;
5280
5281   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5282   jresult = (void *)result;
5283   return jresult;
5284 }
5285
5286
5287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5288   void * jresult ;
5289   Dali::Vector3 *result = 0 ;
5290
5291   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5292   jresult = (void *)result;
5293   return jresult;
5294 }
5295
5296
5297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5298   void * jresult ;
5299   Dali::Vector3 *result = 0 ;
5300
5301   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5302   jresult = (void *)result;
5303   return jresult;
5304 }
5305
5306
5307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5308   void * jresult ;
5309   Dali::Vector3 *result = 0 ;
5310
5311   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5312   jresult = (void *)result;
5313   return jresult;
5314 }
5315
5316
5317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5318   void * jresult ;
5319   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5320   float *arg2 = (float *) 0 ;
5321   Dali::Vector3 *result = 0 ;
5322
5323   arg1 = (Dali::Vector3 *)jarg1;
5324   arg2 = jarg2;
5325   {
5326     try {
5327       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5328     } catch (std::out_of_range& e) {
5329       {
5330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5331       };
5332     } catch (std::exception& e) {
5333       {
5334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5335       };
5336     } catch (...) {
5337       {
5338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5339       };
5340     }
5341   }
5342   jresult = (void *)result;
5343
5344
5345   return jresult;
5346 }
5347
5348
5349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5350   void * jresult ;
5351   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5352   Dali::Vector2 *arg2 = 0 ;
5353   Dali::Vector3 *result = 0 ;
5354
5355   arg1 = (Dali::Vector3 *)jarg1;
5356   arg2 = (Dali::Vector2 *)jarg2;
5357   if (!arg2) {
5358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5359     return 0;
5360   }
5361   {
5362     try {
5363       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5364     } catch (std::out_of_range& e) {
5365       {
5366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5367       };
5368     } catch (std::exception& e) {
5369       {
5370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5371       };
5372     } catch (...) {
5373       {
5374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5375       };
5376     }
5377   }
5378   jresult = (void *)result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5384   void * jresult ;
5385   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5386   Dali::Vector4 *arg2 = 0 ;
5387   Dali::Vector3 *result = 0 ;
5388
5389   arg1 = (Dali::Vector3 *)jarg1;
5390   arg2 = (Dali::Vector4 *)jarg2;
5391   if (!arg2) {
5392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5393     return 0;
5394   }
5395   {
5396     try {
5397       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5398     } catch (std::out_of_range& e) {
5399       {
5400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5401       };
5402     } catch (std::exception& e) {
5403       {
5404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5405       };
5406     } catch (...) {
5407       {
5408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5409       };
5410     }
5411   }
5412   jresult = (void *)result;
5413   return jresult;
5414 }
5415
5416
5417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5418   void * jresult ;
5419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5420   Dali::Vector3 *arg2 = 0 ;
5421   Dali::Vector3 result;
5422
5423   arg1 = (Dali::Vector3 *)jarg1;
5424   arg2 = (Dali::Vector3 *)jarg2;
5425   if (!arg2) {
5426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5427     return 0;
5428   }
5429   {
5430     try {
5431       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5432     } catch (std::out_of_range& e) {
5433       {
5434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5435       };
5436     } catch (std::exception& e) {
5437       {
5438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5439       };
5440     } catch (...) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5443       };
5444     }
5445   }
5446   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5447   return jresult;
5448 }
5449
5450
5451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5452   void * jresult ;
5453   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5454   Dali::Vector3 *arg2 = 0 ;
5455   Dali::Vector3 *result = 0 ;
5456
5457   arg1 = (Dali::Vector3 *)jarg1;
5458   arg2 = (Dali::Vector3 *)jarg2;
5459   if (!arg2) {
5460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5461     return 0;
5462   }
5463   {
5464     try {
5465       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5466     } catch (std::out_of_range& e) {
5467       {
5468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5469       };
5470     } catch (std::exception& e) {
5471       {
5472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5473       };
5474     } catch (...) {
5475       {
5476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5477       };
5478     }
5479   }
5480   jresult = (void *)result;
5481   return jresult;
5482 }
5483
5484
5485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5486   void * jresult ;
5487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5488   Dali::Vector3 *arg2 = 0 ;
5489   Dali::Vector3 result;
5490
5491   arg1 = (Dali::Vector3 *)jarg1;
5492   arg2 = (Dali::Vector3 *)jarg2;
5493   if (!arg2) {
5494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5495     return 0;
5496   }
5497   {
5498     try {
5499       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5500     } catch (std::out_of_range& e) {
5501       {
5502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5503       };
5504     } catch (std::exception& e) {
5505       {
5506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5507       };
5508     } catch (...) {
5509       {
5510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5511       };
5512     }
5513   }
5514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5515   return jresult;
5516 }
5517
5518
5519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5520   void * jresult ;
5521   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5522   Dali::Vector3 *arg2 = 0 ;
5523   Dali::Vector3 *result = 0 ;
5524
5525   arg1 = (Dali::Vector3 *)jarg1;
5526   arg2 = (Dali::Vector3 *)jarg2;
5527   if (!arg2) {
5528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5529     return 0;
5530   }
5531   {
5532     try {
5533       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5534     } catch (std::out_of_range& e) {
5535       {
5536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5537       };
5538     } catch (std::exception& e) {
5539       {
5540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5541       };
5542     } catch (...) {
5543       {
5544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5545       };
5546     }
5547   }
5548   jresult = (void *)result;
5549   return jresult;
5550 }
5551
5552
5553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5554   void * jresult ;
5555   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5556   Dali::Vector3 *arg2 = 0 ;
5557   Dali::Vector3 result;
5558
5559   arg1 = (Dali::Vector3 *)jarg1;
5560   arg2 = (Dali::Vector3 *)jarg2;
5561   if (!arg2) {
5562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5563     return 0;
5564   }
5565   {
5566     try {
5567       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5568     } catch (std::out_of_range& e) {
5569       {
5570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5571       };
5572     } catch (std::exception& e) {
5573       {
5574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5575       };
5576     } catch (...) {
5577       {
5578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5579       };
5580     }
5581   }
5582   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5588   void * jresult ;
5589   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5590   float arg2 ;
5591   Dali::Vector3 result;
5592
5593   arg1 = (Dali::Vector3 *)jarg1;
5594   arg2 = (float)jarg2;
5595   {
5596     try {
5597       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5598     } catch (std::out_of_range& e) {
5599       {
5600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (std::exception& e) {
5603       {
5604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5618   void * jresult ;
5619   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5620   Dali::Vector3 *arg2 = 0 ;
5621   Dali::Vector3 *result = 0 ;
5622
5623   arg1 = (Dali::Vector3 *)jarg1;
5624   arg2 = (Dali::Vector3 *)jarg2;
5625   if (!arg2) {
5626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5627     return 0;
5628   }
5629   {
5630     try {
5631       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5632     } catch (std::out_of_range& e) {
5633       {
5634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5635       };
5636     } catch (std::exception& e) {
5637       {
5638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5639       };
5640     } catch (...) {
5641       {
5642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5643       };
5644     }
5645   }
5646   jresult = (void *)result;
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5652   void * jresult ;
5653   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5654   float arg2 ;
5655   Dali::Vector3 *result = 0 ;
5656
5657   arg1 = (Dali::Vector3 *)jarg1;
5658   arg2 = (float)jarg2;
5659   {
5660     try {
5661       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5662     } catch (std::out_of_range& e) {
5663       {
5664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (std::exception& e) {
5667       {
5668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676   jresult = (void *)result;
5677   return jresult;
5678 }
5679
5680
5681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5682   void * jresult ;
5683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5684   Dali::Quaternion *arg2 = 0 ;
5685   Dali::Vector3 *result = 0 ;
5686
5687   arg1 = (Dali::Vector3 *)jarg1;
5688   arg2 = (Dali::Quaternion *)jarg2;
5689   if (!arg2) {
5690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5691     return 0;
5692   }
5693   {
5694     try {
5695       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5696     } catch (std::out_of_range& e) {
5697       {
5698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (std::exception& e) {
5701       {
5702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710   jresult = (void *)result;
5711   return jresult;
5712 }
5713
5714
5715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5716   void * jresult ;
5717   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5718   Dali::Vector3 *arg2 = 0 ;
5719   Dali::Vector3 result;
5720
5721   arg1 = (Dali::Vector3 *)jarg1;
5722   arg2 = (Dali::Vector3 *)jarg2;
5723   if (!arg2) {
5724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5725     return 0;
5726   }
5727   {
5728     try {
5729       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5730     } catch (std::out_of_range& e) {
5731       {
5732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5733       };
5734     } catch (std::exception& e) {
5735       {
5736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5737       };
5738     } catch (...) {
5739       {
5740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5741       };
5742     }
5743   }
5744   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5745   return jresult;
5746 }
5747
5748
5749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5750   void * jresult ;
5751   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5752   float arg2 ;
5753   Dali::Vector3 result;
5754
5755   arg1 = (Dali::Vector3 *)jarg1;
5756   arg2 = (float)jarg2;
5757   {
5758     try {
5759       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5760     } catch (std::out_of_range& e) {
5761       {
5762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5763       };
5764     } catch (std::exception& e) {
5765       {
5766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5767       };
5768     } catch (...) {
5769       {
5770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5771       };
5772     }
5773   }
5774   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5780   void * jresult ;
5781   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5782   Dali::Vector3 *arg2 = 0 ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   arg1 = (Dali::Vector3 *)jarg1;
5786   arg2 = (Dali::Vector3 *)jarg2;
5787   if (!arg2) {
5788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5789     return 0;
5790   }
5791   {
5792     try {
5793       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5794     } catch (std::out_of_range& e) {
5795       {
5796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5797       };
5798     } catch (std::exception& e) {
5799       {
5800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5801       };
5802     } catch (...) {
5803       {
5804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5805       };
5806     }
5807   }
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5814   void * jresult ;
5815   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5816   float arg2 ;
5817   Dali::Vector3 *result = 0 ;
5818
5819   arg1 = (Dali::Vector3 *)jarg1;
5820   arg2 = (float)jarg2;
5821   {
5822     try {
5823       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5824     } catch (std::out_of_range& e) {
5825       {
5826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5827       };
5828     } catch (std::exception& e) {
5829       {
5830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5831       };
5832     } catch (...) {
5833       {
5834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5835       };
5836     }
5837   }
5838   jresult = (void *)result;
5839   return jresult;
5840 }
5841
5842
5843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5844   void * jresult ;
5845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5846   Dali::Vector3 result;
5847
5848   arg1 = (Dali::Vector3 *)jarg1;
5849   {
5850     try {
5851       result = ((Dali::Vector3 const *)arg1)->operator -();
5852     } catch (std::out_of_range& e) {
5853       {
5854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5855       };
5856     } catch (std::exception& e) {
5857       {
5858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5859       };
5860     } catch (...) {
5861       {
5862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5863       };
5864     }
5865   }
5866   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5867   return jresult;
5868 }
5869
5870
5871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5872   unsigned int jresult ;
5873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5874   Dali::Vector3 *arg2 = 0 ;
5875   bool result;
5876
5877   arg1 = (Dali::Vector3 *)jarg1;
5878   arg2 = (Dali::Vector3 *)jarg2;
5879   if (!arg2) {
5880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5881     return 0;
5882   }
5883   {
5884     try {
5885       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5886     } catch (std::out_of_range& e) {
5887       {
5888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (std::exception& e) {
5891       {
5892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (...) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5897       };
5898     }
5899   }
5900   jresult = result;
5901   return jresult;
5902 }
5903
5904
5905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5906   unsigned int jresult ;
5907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5908   Dali::Vector3 *arg2 = 0 ;
5909   bool result;
5910
5911   arg1 = (Dali::Vector3 *)jarg1;
5912   arg2 = (Dali::Vector3 *)jarg2;
5913   if (!arg2) {
5914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5915     return 0;
5916   }
5917   {
5918     try {
5919       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5920     } catch (std::out_of_range& e) {
5921       {
5922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5923       };
5924     } catch (std::exception& e) {
5925       {
5926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5927       };
5928     } catch (...) {
5929       {
5930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5931       };
5932     }
5933   }
5934   jresult = result;
5935   return jresult;
5936 }
5937
5938
5939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5940   float jresult ;
5941   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5942   unsigned int arg2 ;
5943   float *result = 0 ;
5944
5945   arg1 = (Dali::Vector3 *)jarg1;
5946   arg2 = (unsigned int)jarg2;
5947   {
5948     try {
5949       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5950     } catch (std::out_of_range& e) {
5951       {
5952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5953       };
5954     } catch (std::exception& e) {
5955       {
5956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5957       };
5958     } catch (...) {
5959       {
5960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5961       };
5962     }
5963   }
5964   jresult = *result;
5965   return jresult;
5966 }
5967
5968
5969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5970   float jresult ;
5971   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5972   Dali::Vector3 *arg2 = 0 ;
5973   float result;
5974
5975   arg1 = (Dali::Vector3 *)jarg1;
5976   arg2 = (Dali::Vector3 *)jarg2;
5977   if (!arg2) {
5978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5979     return 0;
5980   }
5981   {
5982     try {
5983       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5984     } catch (std::out_of_range& e) {
5985       {
5986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5987       };
5988     } catch (std::exception& e) {
5989       {
5990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5991       };
5992     } catch (...) {
5993       {
5994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5995       };
5996     }
5997   }
5998   jresult = result;
5999   return jresult;
6000 }
6001
6002
6003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6004   void * jresult ;
6005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6006   Dali::Vector3 *arg2 = 0 ;
6007   Dali::Vector3 result;
6008
6009   arg1 = (Dali::Vector3 *)jarg1;
6010   arg2 = (Dali::Vector3 *)jarg2;
6011   if (!arg2) {
6012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6013     return 0;
6014   }
6015   {
6016     try {
6017       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6018     } catch (std::out_of_range& e) {
6019       {
6020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6021       };
6022     } catch (std::exception& e) {
6023       {
6024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6025       };
6026     } catch (...) {
6027       {
6028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6029       };
6030     }
6031   }
6032   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6033   return jresult;
6034 }
6035
6036
6037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6038   float jresult ;
6039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6040   float result;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   {
6044     try {
6045       result = (float)((Dali::Vector3 const *)arg1)->Length();
6046     } catch (std::out_of_range& e) {
6047       {
6048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (std::exception& e) {
6051       {
6052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (...) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6057       };
6058     }
6059   }
6060   jresult = result;
6061   return jresult;
6062 }
6063
6064
6065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6066   float jresult ;
6067   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6068   float result;
6069
6070   arg1 = (Dali::Vector3 *)jarg1;
6071   {
6072     try {
6073       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6074     } catch (std::out_of_range& e) {
6075       {
6076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6077       };
6078     } catch (std::exception& e) {
6079       {
6080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6081       };
6082     } catch (...) {
6083       {
6084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6085       };
6086     }
6087   }
6088   jresult = result;
6089   return jresult;
6090 }
6091
6092
6093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6095
6096   arg1 = (Dali::Vector3 *)jarg1;
6097   {
6098     try {
6099       (arg1)->Normalize();
6100     } catch (std::out_of_range& e) {
6101       {
6102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6103       };
6104     } catch (std::exception& e) {
6105       {
6106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6107       };
6108     } catch (...) {
6109       {
6110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6111       };
6112     }
6113   }
6114 }
6115
6116
6117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6118   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6119   Dali::Vector3 *arg2 = 0 ;
6120   Dali::Vector3 *arg3 = 0 ;
6121
6122   arg1 = (Dali::Vector3 *)jarg1;
6123   arg2 = (Dali::Vector3 *)jarg2;
6124   if (!arg2) {
6125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6126     return ;
6127   }
6128   arg3 = (Dali::Vector3 *)jarg3;
6129   if (!arg3) {
6130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6131     return ;
6132   }
6133   {
6134     try {
6135       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6136     } catch (std::out_of_range& e) {
6137       {
6138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6139       };
6140     } catch (std::exception& e) {
6141       {
6142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6147       };
6148     }
6149   }
6150 }
6151
6152
6153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6154   void * jresult ;
6155   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6156   float *result = 0 ;
6157
6158   arg1 = (Dali::Vector3 *)jarg1;
6159   {
6160     try {
6161       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6162     } catch (std::out_of_range& e) {
6163       {
6164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6165       };
6166     } catch (std::exception& e) {
6167       {
6168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6169       };
6170     } catch (...) {
6171       {
6172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6173       };
6174     }
6175   }
6176   jresult = (void *)result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6182   void * jresult ;
6183   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6184   Dali::Vector2 *result = 0 ;
6185
6186   arg1 = (Dali::Vector3 *)jarg1;
6187   {
6188     try {
6189       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6190     } catch (std::out_of_range& e) {
6191       {
6192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6193       };
6194     } catch (std::exception& e) {
6195       {
6196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (...) {
6199       {
6200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6201       };
6202     }
6203   }
6204   jresult = (void *)result;
6205   return jresult;
6206 }
6207
6208
6209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6210   void * jresult ;
6211   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6212   Dali::Vector2 *result = 0 ;
6213
6214   arg1 = (Dali::Vector3 *)jarg1;
6215   {
6216     try {
6217       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6218     } catch (std::out_of_range& e) {
6219       {
6220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6221       };
6222     } catch (std::exception& e) {
6223       {
6224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6225       };
6226     } catch (...) {
6227       {
6228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6229       };
6230     }
6231   }
6232   jresult = (void *)result;
6233   return jresult;
6234 }
6235
6236
6237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6239   float arg2 ;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   arg2 = (float)jarg2;
6243   if (arg1) (arg1)->x = arg2;
6244 }
6245
6246
6247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6248   float jresult ;
6249   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6250   float result;
6251
6252   arg1 = (Dali::Vector3 *)jarg1;
6253   result = (float) ((arg1)->x);
6254   jresult = result;
6255   return jresult;
6256 }
6257
6258
6259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6260   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6261   float arg2 ;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (float)jarg2;
6265   if (arg1) (arg1)->width = arg2;
6266 }
6267
6268
6269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6270   float jresult ;
6271   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6272   float result;
6273
6274   arg1 = (Dali::Vector3 *)jarg1;
6275   result = (float) ((arg1)->width);
6276   jresult = result;
6277   return jresult;
6278 }
6279
6280
6281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6282   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6283   float arg2 ;
6284
6285   arg1 = (Dali::Vector3 *)jarg1;
6286   arg2 = (float)jarg2;
6287   if (arg1) (arg1)->r = arg2;
6288 }
6289
6290
6291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6292   float jresult ;
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   float result;
6295
6296   arg1 = (Dali::Vector3 *)jarg1;
6297   result = (float) ((arg1)->r);
6298   jresult = result;
6299   return jresult;
6300 }
6301
6302
6303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   float arg2 ;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (float)jarg2;
6309   if (arg1) (arg1)->y = arg2;
6310 }
6311
6312
6313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6314   float jresult ;
6315   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6316   float result;
6317
6318   arg1 = (Dali::Vector3 *)jarg1;
6319   result = (float) ((arg1)->y);
6320   jresult = result;
6321   return jresult;
6322 }
6323
6324
6325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6326   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6327   float arg2 ;
6328
6329   arg1 = (Dali::Vector3 *)jarg1;
6330   arg2 = (float)jarg2;
6331   if (arg1) (arg1)->height = arg2;
6332 }
6333
6334
6335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6336   float jresult ;
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338   float result;
6339
6340   arg1 = (Dali::Vector3 *)jarg1;
6341   result = (float) ((arg1)->height);
6342   jresult = result;
6343   return jresult;
6344 }
6345
6346
6347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6348   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6349   float arg2 ;
6350
6351   arg1 = (Dali::Vector3 *)jarg1;
6352   arg2 = (float)jarg2;
6353   if (arg1) (arg1)->g = arg2;
6354 }
6355
6356
6357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6358   float jresult ;
6359   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6360   float result;
6361
6362   arg1 = (Dali::Vector3 *)jarg1;
6363   result = (float) ((arg1)->g);
6364   jresult = result;
6365   return jresult;
6366 }
6367
6368
6369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6370   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6371   float arg2 ;
6372
6373   arg1 = (Dali::Vector3 *)jarg1;
6374   arg2 = (float)jarg2;
6375   if (arg1) (arg1)->z = arg2;
6376 }
6377
6378
6379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6380   float jresult ;
6381   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6382   float result;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   result = (float) ((arg1)->z);
6386   jresult = result;
6387   return jresult;
6388 }
6389
6390
6391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6392   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6393   float arg2 ;
6394
6395   arg1 = (Dali::Vector3 *)jarg1;
6396   arg2 = (float)jarg2;
6397   if (arg1) (arg1)->depth = arg2;
6398 }
6399
6400
6401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6402   float jresult ;
6403   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6404   float result;
6405
6406   arg1 = (Dali::Vector3 *)jarg1;
6407   result = (float) ((arg1)->depth);
6408   jresult = result;
6409   return jresult;
6410 }
6411
6412
6413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6414   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6415   float arg2 ;
6416
6417   arg1 = (Dali::Vector3 *)jarg1;
6418   arg2 = (float)jarg2;
6419   if (arg1) (arg1)->b = arg2;
6420 }
6421
6422
6423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6424   float jresult ;
6425   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6426   float result;
6427
6428   arg1 = (Dali::Vector3 *)jarg1;
6429   result = (float) ((arg1)->b);
6430   jresult = result;
6431   return jresult;
6432 }
6433
6434
6435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6436   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6437
6438   arg1 = (Dali::Vector3 *)jarg1;
6439   {
6440     try {
6441       delete arg1;
6442     } catch (std::out_of_range& e) {
6443       {
6444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6445       };
6446     } catch (std::exception& e) {
6447       {
6448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6449       };
6450     } catch (...) {
6451       {
6452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6453       };
6454     }
6455   }
6456 }
6457
6458
6459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6460   void * jresult ;
6461   Dali::Vector3 *arg1 = 0 ;
6462   Dali::Vector3 *arg2 = 0 ;
6463   Dali::Vector3 result;
6464
6465   arg1 = (Dali::Vector3 *)jarg1;
6466   if (!arg1) {
6467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6468     return 0;
6469   }
6470   arg2 = (Dali::Vector3 *)jarg2;
6471   if (!arg2) {
6472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6473     return 0;
6474   }
6475   {
6476     try {
6477       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6478     } catch (std::out_of_range& e) {
6479       {
6480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6481       };
6482     } catch (std::exception& e) {
6483       {
6484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6485       };
6486     } catch (...) {
6487       {
6488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6489       };
6490     }
6491   }
6492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6493   return jresult;
6494 }
6495
6496
6497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6498   void * jresult ;
6499   Dali::Vector3 *arg1 = 0 ;
6500   Dali::Vector3 *arg2 = 0 ;
6501   Dali::Vector3 result;
6502
6503   arg1 = (Dali::Vector3 *)jarg1;
6504   if (!arg1) {
6505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6506     return 0;
6507   }
6508   arg2 = (Dali::Vector3 *)jarg2;
6509   if (!arg2) {
6510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6511     return 0;
6512   }
6513   {
6514     try {
6515       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6516     } catch (std::out_of_range& e) {
6517       {
6518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6519       };
6520     } catch (std::exception& e) {
6521       {
6522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6523       };
6524     } catch (...) {
6525       {
6526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6527       };
6528     }
6529   }
6530   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6531   return jresult;
6532 }
6533
6534
6535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6536   void * jresult ;
6537   Dali::Vector3 *arg1 = 0 ;
6538   float *arg2 = 0 ;
6539   float *arg3 = 0 ;
6540   float temp2 ;
6541   float temp3 ;
6542   Dali::Vector3 result;
6543
6544   arg1 = (Dali::Vector3 *)jarg1;
6545   if (!arg1) {
6546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6547     return 0;
6548   }
6549   temp2 = (float)jarg2;
6550   arg2 = &temp2;
6551   temp3 = (float)jarg3;
6552   arg3 = &temp3;
6553   {
6554     try {
6555       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6556     } catch (std::out_of_range& e) {
6557       {
6558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6559       };
6560     } catch (std::exception& e) {
6561       {
6562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6563       };
6564     } catch (...) {
6565       {
6566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6567       };
6568     }
6569   }
6570   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6571   return jresult;
6572 }
6573
6574
6575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6576   void * jresult ;
6577   Dali::Vector4 *result = 0 ;
6578
6579   {
6580     try {
6581       result = (Dali::Vector4 *)new Dali::Vector4();
6582     } catch (std::out_of_range& e) {
6583       {
6584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6585       };
6586     } catch (std::exception& e) {
6587       {
6588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6589       };
6590     } catch (...) {
6591       {
6592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6593       };
6594     }
6595   }
6596   jresult = (void *)result;
6597   return jresult;
6598 }
6599
6600
6601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6602   void * jresult ;
6603   float arg1 ;
6604   float arg2 ;
6605   float arg3 ;
6606   float arg4 ;
6607   Dali::Vector4 *result = 0 ;
6608
6609   arg1 = (float)jarg1;
6610   arg2 = (float)jarg2;
6611   arg3 = (float)jarg3;
6612   arg4 = (float)jarg4;
6613   {
6614     try {
6615       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6616     } catch (std::out_of_range& e) {
6617       {
6618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6619       };
6620     } catch (std::exception& e) {
6621       {
6622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6623       };
6624     } catch (...) {
6625       {
6626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6627       };
6628     }
6629   }
6630   jresult = (void *)result;
6631   return jresult;
6632 }
6633
6634
6635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6636   void * jresult ;
6637   float *arg1 = (float *) 0 ;
6638   Dali::Vector4 *result = 0 ;
6639
6640   arg1 = jarg1;
6641   {
6642     try {
6643       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6644     } catch (std::out_of_range& e) {
6645       {
6646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6647       };
6648     } catch (std::exception& e) {
6649       {
6650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6651       };
6652     } catch (...) {
6653       {
6654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6655       };
6656     }
6657   }
6658   jresult = (void *)result;
6659
6660
6661   return jresult;
6662 }
6663
6664
6665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6666   void * jresult ;
6667   Dali::Vector2 *arg1 = 0 ;
6668   Dali::Vector4 *result = 0 ;
6669
6670   arg1 = (Dali::Vector2 *)jarg1;
6671   if (!arg1) {
6672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6673     return 0;
6674   }
6675   {
6676     try {
6677       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6678     } catch (std::out_of_range& e) {
6679       {
6680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6681       };
6682     } catch (std::exception& e) {
6683       {
6684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (...) {
6687       {
6688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6689       };
6690     }
6691   }
6692   jresult = (void *)result;
6693   return jresult;
6694 }
6695
6696
6697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6698   void * jresult ;
6699   Dali::Vector3 *arg1 = 0 ;
6700   Dali::Vector4 *result = 0 ;
6701
6702   arg1 = (Dali::Vector3 *)jarg1;
6703   if (!arg1) {
6704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6705     return 0;
6706   }
6707   {
6708     try {
6709       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6710     } catch (std::out_of_range& e) {
6711       {
6712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6713       };
6714     } catch (std::exception& e) {
6715       {
6716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (...) {
6719       {
6720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6721       };
6722     }
6723   }
6724   jresult = (void *)result;
6725   return jresult;
6726 }
6727
6728
6729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6730   void * jresult ;
6731   Dali::Vector4 *result = 0 ;
6732
6733   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6734   jresult = (void *)result;
6735   return jresult;
6736 }
6737
6738
6739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6740   void * jresult ;
6741   Dali::Vector4 *result = 0 ;
6742
6743   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6744   jresult = (void *)result;
6745   return jresult;
6746 }
6747
6748
6749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6750   void * jresult ;
6751   Dali::Vector4 *result = 0 ;
6752
6753   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6754   jresult = (void *)result;
6755   return jresult;
6756 }
6757
6758
6759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6760   void * jresult ;
6761   Dali::Vector4 *result = 0 ;
6762
6763   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6764   jresult = (void *)result;
6765   return jresult;
6766 }
6767
6768
6769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6770   void * jresult ;
6771   Dali::Vector4 *result = 0 ;
6772
6773   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6774   jresult = (void *)result;
6775   return jresult;
6776 }
6777
6778
6779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6780   void * jresult ;
6781   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6782   float *arg2 = (float *) 0 ;
6783   Dali::Vector4 *result = 0 ;
6784
6785   arg1 = (Dali::Vector4 *)jarg1;
6786   arg2 = jarg2;
6787   {
6788     try {
6789       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6797       };
6798     } catch (...) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6801       };
6802     }
6803   }
6804   jresult = (void *)result;
6805
6806
6807   return jresult;
6808 }
6809
6810
6811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6812   void * jresult ;
6813   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6814   Dali::Vector2 *arg2 = 0 ;
6815   Dali::Vector4 *result = 0 ;
6816
6817   arg1 = (Dali::Vector4 *)jarg1;
6818   arg2 = (Dali::Vector2 *)jarg2;
6819   if (!arg2) {
6820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6821     return 0;
6822   }
6823   {
6824     try {
6825       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6826     } catch (std::out_of_range& e) {
6827       {
6828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6829       };
6830     } catch (std::exception& e) {
6831       {
6832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (...) {
6835       {
6836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6837       };
6838     }
6839   }
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6846   void * jresult ;
6847   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6848   Dali::Vector3 *arg2 = 0 ;
6849   Dali::Vector4 *result = 0 ;
6850
6851   arg1 = (Dali::Vector4 *)jarg1;
6852   arg2 = (Dali::Vector3 *)jarg2;
6853   if (!arg2) {
6854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6855     return 0;
6856   }
6857   {
6858     try {
6859       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6860     } catch (std::out_of_range& e) {
6861       {
6862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6863       };
6864     } catch (std::exception& e) {
6865       {
6866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6867       };
6868     } catch (...) {
6869       {
6870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6871       };
6872     }
6873   }
6874   jresult = (void *)result;
6875   return jresult;
6876 }
6877
6878
6879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6880   void * jresult ;
6881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6882   Dali::Vector4 *arg2 = 0 ;
6883   Dali::Vector4 result;
6884
6885   arg1 = (Dali::Vector4 *)jarg1;
6886   arg2 = (Dali::Vector4 *)jarg2;
6887   if (!arg2) {
6888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6889     return 0;
6890   }
6891   {
6892     try {
6893       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6894     } catch (std::out_of_range& e) {
6895       {
6896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6897       };
6898     } catch (std::exception& e) {
6899       {
6900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6901       };
6902     } catch (...) {
6903       {
6904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6905       };
6906     }
6907   }
6908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6909   return jresult;
6910 }
6911
6912
6913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6914   void * jresult ;
6915   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6916   Dali::Vector4 *arg2 = 0 ;
6917   Dali::Vector4 *result = 0 ;
6918
6919   arg1 = (Dali::Vector4 *)jarg1;
6920   arg2 = (Dali::Vector4 *)jarg2;
6921   if (!arg2) {
6922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6923     return 0;
6924   }
6925   {
6926     try {
6927       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6928     } catch (std::out_of_range& e) {
6929       {
6930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6931       };
6932     } catch (std::exception& e) {
6933       {
6934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6935       };
6936     } catch (...) {
6937       {
6938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6939       };
6940     }
6941   }
6942   jresult = (void *)result;
6943   return jresult;
6944 }
6945
6946
6947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6948   void * jresult ;
6949   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6950   Dali::Vector4 *arg2 = 0 ;
6951   Dali::Vector4 result;
6952
6953   arg1 = (Dali::Vector4 *)jarg1;
6954   arg2 = (Dali::Vector4 *)jarg2;
6955   if (!arg2) {
6956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6957     return 0;
6958   }
6959   {
6960     try {
6961       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6962     } catch (std::out_of_range& e) {
6963       {
6964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6965       };
6966     } catch (std::exception& e) {
6967       {
6968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6969       };
6970     } catch (...) {
6971       {
6972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6973       };
6974     }
6975   }
6976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6977   return jresult;
6978 }
6979
6980
6981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6982   void * jresult ;
6983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6984   Dali::Vector4 *arg2 = 0 ;
6985   Dali::Vector4 *result = 0 ;
6986
6987   arg1 = (Dali::Vector4 *)jarg1;
6988   arg2 = (Dali::Vector4 *)jarg2;
6989   if (!arg2) {
6990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6991     return 0;
6992   }
6993   {
6994     try {
6995       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6996     } catch (std::out_of_range& e) {
6997       {
6998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6999       };
7000     } catch (std::exception& e) {
7001       {
7002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7003       };
7004     } catch (...) {
7005       {
7006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7007       };
7008     }
7009   }
7010   jresult = (void *)result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7016   void * jresult ;
7017   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7018   Dali::Vector4 *arg2 = 0 ;
7019   Dali::Vector4 result;
7020
7021   arg1 = (Dali::Vector4 *)jarg1;
7022   arg2 = (Dali::Vector4 *)jarg2;
7023   if (!arg2) {
7024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7025     return 0;
7026   }
7027   {
7028     try {
7029       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7030     } catch (std::out_of_range& e) {
7031       {
7032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7033       };
7034     } catch (std::exception& e) {
7035       {
7036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7037       };
7038     } catch (...) {
7039       {
7040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7041       };
7042     }
7043   }
7044   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7045   return jresult;
7046 }
7047
7048
7049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7050   void * jresult ;
7051   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7052   float arg2 ;
7053   Dali::Vector4 result;
7054
7055   arg1 = (Dali::Vector4 *)jarg1;
7056   arg2 = (float)jarg2;
7057   {
7058     try {
7059       result = ((Dali::Vector4 const *)arg1)->operator *(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 (...) {
7069       {
7070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7071       };
7072     }
7073   }
7074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7080   void * jresult ;
7081   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7082   Dali::Vector4 *arg2 = 0 ;
7083   Dali::Vector4 *result = 0 ;
7084
7085   arg1 = (Dali::Vector4 *)jarg1;
7086   arg2 = (Dali::Vector4 *)jarg2;
7087   if (!arg2) {
7088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7089     return 0;
7090   }
7091   {
7092     try {
7093       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7094     } catch (std::out_of_range& e) {
7095       {
7096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7097       };
7098     } catch (std::exception& e) {
7099       {
7100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7101       };
7102     } catch (...) {
7103       {
7104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7105       };
7106     }
7107   }
7108   jresult = (void *)result;
7109   return jresult;
7110 }
7111
7112
7113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7114   void * jresult ;
7115   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7116   float arg2 ;
7117   Dali::Vector4 *result = 0 ;
7118
7119   arg1 = (Dali::Vector4 *)jarg1;
7120   arg2 = (float)jarg2;
7121   {
7122     try {
7123       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7124     } catch (std::out_of_range& e) {
7125       {
7126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7127       };
7128     } catch (std::exception& e) {
7129       {
7130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7131       };
7132     } catch (...) {
7133       {
7134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7135       };
7136     }
7137   }
7138   jresult = (void *)result;
7139   return jresult;
7140 }
7141
7142
7143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7144   void * jresult ;
7145   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7146   Dali::Vector4 *arg2 = 0 ;
7147   Dali::Vector4 result;
7148
7149   arg1 = (Dali::Vector4 *)jarg1;
7150   arg2 = (Dali::Vector4 *)jarg2;
7151   if (!arg2) {
7152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7153     return 0;
7154   }
7155   {
7156     try {
7157       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7158     } catch (std::out_of_range& e) {
7159       {
7160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (std::exception& e) {
7163       {
7164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7165       };
7166     } catch (...) {
7167       {
7168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7169       };
7170     }
7171   }
7172   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7173   return jresult;
7174 }
7175
7176
7177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7178   void * jresult ;
7179   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7180   float arg2 ;
7181   Dali::Vector4 result;
7182
7183   arg1 = (Dali::Vector4 *)jarg1;
7184   arg2 = (float)jarg2;
7185   {
7186     try {
7187       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7188     } catch (std::out_of_range& e) {
7189       {
7190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7191       };
7192     } catch (std::exception& e) {
7193       {
7194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7195       };
7196     } catch (...) {
7197       {
7198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7199       };
7200     }
7201   }
7202   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7203   return jresult;
7204 }
7205
7206
7207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7208   void * jresult ;
7209   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7210   Dali::Vector4 *arg2 = 0 ;
7211   Dali::Vector4 *result = 0 ;
7212
7213   arg1 = (Dali::Vector4 *)jarg1;
7214   arg2 = (Dali::Vector4 *)jarg2;
7215   if (!arg2) {
7216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7217     return 0;
7218   }
7219   {
7220     try {
7221       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7222     } catch (std::out_of_range& e) {
7223       {
7224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7225       };
7226     } catch (std::exception& e) {
7227       {
7228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7229       };
7230     } catch (...) {
7231       {
7232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7233       };
7234     }
7235   }
7236   jresult = (void *)result;
7237   return jresult;
7238 }
7239
7240
7241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7242   void * jresult ;
7243   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7244   float arg2 ;
7245   Dali::Vector4 *result = 0 ;
7246
7247   arg1 = (Dali::Vector4 *)jarg1;
7248   arg2 = (float)jarg2;
7249   {
7250     try {
7251       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7252     } catch (std::out_of_range& e) {
7253       {
7254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7255       };
7256     } catch (std::exception& e) {
7257       {
7258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7259       };
7260     } catch (...) {
7261       {
7262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7263       };
7264     }
7265   }
7266   jresult = (void *)result;
7267   return jresult;
7268 }
7269
7270
7271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7272   void * jresult ;
7273   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7274   Dali::Vector4 result;
7275
7276   arg1 = (Dali::Vector4 *)jarg1;
7277   {
7278     try {
7279       result = ((Dali::Vector4 const *)arg1)->operator -();
7280     } catch (std::out_of_range& e) {
7281       {
7282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (std::exception& e) {
7285       {
7286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7295   return jresult;
7296 }
7297
7298
7299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7300   unsigned int jresult ;
7301   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7302   Dali::Vector4 *arg2 = 0 ;
7303   bool result;
7304
7305   arg1 = (Dali::Vector4 *)jarg1;
7306   arg2 = (Dali::Vector4 *)jarg2;
7307   if (!arg2) {
7308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7309     return 0;
7310   }
7311   {
7312     try {
7313       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7314     } catch (std::out_of_range& e) {
7315       {
7316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7317       };
7318     } catch (std::exception& e) {
7319       {
7320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7321       };
7322     } catch (...) {
7323       {
7324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7325       };
7326     }
7327   }
7328   jresult = result;
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7334   unsigned int jresult ;
7335   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7336   Dali::Vector4 *arg2 = 0 ;
7337   bool result;
7338
7339   arg1 = (Dali::Vector4 *)jarg1;
7340   arg2 = (Dali::Vector4 *)jarg2;
7341   if (!arg2) {
7342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7343     return 0;
7344   }
7345   {
7346     try {
7347       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (...) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7359       };
7360     }
7361   }
7362   jresult = result;
7363   return jresult;
7364 }
7365
7366
7367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7368   float jresult ;
7369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7370   unsigned int arg2 ;
7371   float *result = 0 ;
7372
7373   arg1 = (Dali::Vector4 *)jarg1;
7374   arg2 = (unsigned int)jarg2;
7375   {
7376     try {
7377       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7378     } catch (std::out_of_range& e) {
7379       {
7380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7381       };
7382     } catch (std::exception& e) {
7383       {
7384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7385       };
7386     } catch (...) {
7387       {
7388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7389       };
7390     }
7391   }
7392   jresult = *result;
7393   return jresult;
7394 }
7395
7396
7397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7398   float jresult ;
7399   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7400   Dali::Vector3 *arg2 = 0 ;
7401   float result;
7402
7403   arg1 = (Dali::Vector4 *)jarg1;
7404   arg2 = (Dali::Vector3 *)jarg2;
7405   if (!arg2) {
7406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7407     return 0;
7408   }
7409   {
7410     try {
7411       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7412     } catch (std::out_of_range& e) {
7413       {
7414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7415       };
7416     } catch (std::exception& e) {
7417       {
7418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7419       };
7420     } catch (...) {
7421       {
7422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7423       };
7424     }
7425   }
7426   jresult = result;
7427   return jresult;
7428 }
7429
7430
7431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7432   float jresult ;
7433   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7434   Dali::Vector4 *arg2 = 0 ;
7435   float result;
7436
7437   arg1 = (Dali::Vector4 *)jarg1;
7438   arg2 = (Dali::Vector4 *)jarg2;
7439   if (!arg2) {
7440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7441     return 0;
7442   }
7443   {
7444     try {
7445       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7446     } catch (std::out_of_range& e) {
7447       {
7448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7449       };
7450     } catch (std::exception& e) {
7451       {
7452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7453       };
7454     } catch (...) {
7455       {
7456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7457       };
7458     }
7459   }
7460   jresult = result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7466   float jresult ;
7467   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7468   Dali::Vector4 *arg2 = 0 ;
7469   float result;
7470
7471   arg1 = (Dali::Vector4 *)jarg1;
7472   arg2 = (Dali::Vector4 *)jarg2;
7473   if (!arg2) {
7474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7475     return 0;
7476   }
7477   {
7478     try {
7479       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7480     } catch (std::out_of_range& e) {
7481       {
7482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7483       };
7484     } catch (std::exception& e) {
7485       {
7486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7487       };
7488     } catch (...) {
7489       {
7490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7491       };
7492     }
7493   }
7494   jresult = result;
7495   return jresult;
7496 }
7497
7498
7499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7500   void * jresult ;
7501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7502   Dali::Vector4 *arg2 = 0 ;
7503   Dali::Vector4 result;
7504
7505   arg1 = (Dali::Vector4 *)jarg1;
7506   arg2 = (Dali::Vector4 *)jarg2;
7507   if (!arg2) {
7508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7509     return 0;
7510   }
7511   {
7512     try {
7513       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7514     } catch (std::out_of_range& e) {
7515       {
7516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7517       };
7518     } catch (std::exception& e) {
7519       {
7520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7521       };
7522     } catch (...) {
7523       {
7524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7525       };
7526     }
7527   }
7528   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7529   return jresult;
7530 }
7531
7532
7533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7534   float jresult ;
7535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7536   float result;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   {
7540     try {
7541       result = (float)((Dali::Vector4 const *)arg1)->Length();
7542     } catch (std::out_of_range& e) {
7543       {
7544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (std::exception& e) {
7547       {
7548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (...) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7553       };
7554     }
7555   }
7556   jresult = result;
7557   return jresult;
7558 }
7559
7560
7561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7562   float jresult ;
7563   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7564   float result;
7565
7566   arg1 = (Dali::Vector4 *)jarg1;
7567   {
7568     try {
7569       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7570     } catch (std::out_of_range& e) {
7571       {
7572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7573       };
7574     } catch (std::exception& e) {
7575       {
7576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7577       };
7578     } catch (...) {
7579       {
7580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7581       };
7582     }
7583   }
7584   jresult = result;
7585   return jresult;
7586 }
7587
7588
7589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7591
7592   arg1 = (Dali::Vector4 *)jarg1;
7593   {
7594     try {
7595       (arg1)->Normalize();
7596     } catch (std::out_of_range& e) {
7597       {
7598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7599       };
7600     } catch (std::exception& e) {
7601       {
7602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7603       };
7604     } catch (...) {
7605       {
7606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7607       };
7608     }
7609   }
7610 }
7611
7612
7613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7615   Dali::Vector4 *arg2 = 0 ;
7616   Dali::Vector4 *arg3 = 0 ;
7617
7618   arg1 = (Dali::Vector4 *)jarg1;
7619   arg2 = (Dali::Vector4 *)jarg2;
7620   if (!arg2) {
7621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7622     return ;
7623   }
7624   arg3 = (Dali::Vector4 *)jarg3;
7625   if (!arg3) {
7626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7627     return ;
7628   }
7629   {
7630     try {
7631       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7632     } catch (std::out_of_range& e) {
7633       {
7634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7635       };
7636     } catch (std::exception& e) {
7637       {
7638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7643       };
7644     }
7645   }
7646 }
7647
7648
7649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7650   void * jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   float *result = 0 ;
7653
7654   arg1 = (Dali::Vector4 *)jarg1;
7655   {
7656     try {
7657       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7658     } catch (std::out_of_range& e) {
7659       {
7660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7661       };
7662     } catch (std::exception& e) {
7663       {
7664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7665       };
7666     } catch (...) {
7667       {
7668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7669       };
7670     }
7671   }
7672   jresult = (void *)result;
7673   return jresult;
7674 }
7675
7676
7677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7679   float arg2 ;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   arg2 = (float)jarg2;
7683   if (arg1) (arg1)->x = arg2;
7684 }
7685
7686
7687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7688   float jresult ;
7689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7690   float result;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   result = (float) ((arg1)->x);
7694   jresult = result;
7695   return jresult;
7696 }
7697
7698
7699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7701   float arg2 ;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   arg2 = (float)jarg2;
7705   if (arg1) (arg1)->r = arg2;
7706 }
7707
7708
7709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7710   float jresult ;
7711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7712   float result;
7713
7714   arg1 = (Dali::Vector4 *)jarg1;
7715   result = (float) ((arg1)->r);
7716   jresult = result;
7717   return jresult;
7718 }
7719
7720
7721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   float arg2 ;
7724
7725   arg1 = (Dali::Vector4 *)jarg1;
7726   arg2 = (float)jarg2;
7727   if (arg1) (arg1)->s = arg2;
7728 }
7729
7730
7731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7732   float jresult ;
7733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7734   float result;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   result = (float) ((arg1)->s);
7738   jresult = result;
7739   return jresult;
7740 }
7741
7742
7743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7745   float arg2 ;
7746
7747   arg1 = (Dali::Vector4 *)jarg1;
7748   arg2 = (float)jarg2;
7749   if (arg1) (arg1)->y = arg2;
7750 }
7751
7752
7753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7754   float jresult ;
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   float result;
7757
7758   arg1 = (Dali::Vector4 *)jarg1;
7759   result = (float) ((arg1)->y);
7760   jresult = result;
7761   return jresult;
7762 }
7763
7764
7765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   float arg2 ;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   arg2 = (float)jarg2;
7771   if (arg1) (arg1)->g = arg2;
7772 }
7773
7774
7775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7776   float jresult ;
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float result;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   result = (float) ((arg1)->g);
7782   jresult = result;
7783   return jresult;
7784 }
7785
7786
7787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7789   float arg2 ;
7790
7791   arg1 = (Dali::Vector4 *)jarg1;
7792   arg2 = (float)jarg2;
7793   if (arg1) (arg1)->t = arg2;
7794 }
7795
7796
7797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7798   float jresult ;
7799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7800   float result;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   result = (float) ((arg1)->t);
7804   jresult = result;
7805   return jresult;
7806 }
7807
7808
7809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812
7813   arg1 = (Dali::Vector4 *)jarg1;
7814   arg2 = (float)jarg2;
7815   if (arg1) (arg1)->z = arg2;
7816 }
7817
7818
7819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7820   float jresult ;
7821   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7822   float result;
7823
7824   arg1 = (Dali::Vector4 *)jarg1;
7825   result = (float) ((arg1)->z);
7826   jresult = result;
7827   return jresult;
7828 }
7829
7830
7831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   float arg2 ;
7834
7835   arg1 = (Dali::Vector4 *)jarg1;
7836   arg2 = (float)jarg2;
7837   if (arg1) (arg1)->b = arg2;
7838 }
7839
7840
7841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7842   float jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   float result;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   result = (float) ((arg1)->b);
7848   jresult = result;
7849   return jresult;
7850 }
7851
7852
7853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7854   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7855   float arg2 ;
7856
7857   arg1 = (Dali::Vector4 *)jarg1;
7858   arg2 = (float)jarg2;
7859   if (arg1) (arg1)->p = arg2;
7860 }
7861
7862
7863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7864   float jresult ;
7865   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7866   float result;
7867
7868   arg1 = (Dali::Vector4 *)jarg1;
7869   result = (float) ((arg1)->p);
7870   jresult = result;
7871   return jresult;
7872 }
7873
7874
7875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7876   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7877   float arg2 ;
7878
7879   arg1 = (Dali::Vector4 *)jarg1;
7880   arg2 = (float)jarg2;
7881   if (arg1) (arg1)->w = arg2;
7882 }
7883
7884
7885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7886   float jresult ;
7887   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7888   float result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   result = (float) ((arg1)->w);
7892   jresult = result;
7893   return jresult;
7894 }
7895
7896
7897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7898   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7899   float arg2 ;
7900
7901   arg1 = (Dali::Vector4 *)jarg1;
7902   arg2 = (float)jarg2;
7903   if (arg1) (arg1)->a = arg2;
7904 }
7905
7906
7907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7908   float jresult ;
7909   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7910   float result;
7911
7912   arg1 = (Dali::Vector4 *)jarg1;
7913   result = (float) ((arg1)->a);
7914   jresult = result;
7915   return jresult;
7916 }
7917
7918
7919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7920   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7921   float arg2 ;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (float)jarg2;
7925   if (arg1) (arg1)->q = arg2;
7926 }
7927
7928
7929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7930   float jresult ;
7931   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7932   float result;
7933
7934   arg1 = (Dali::Vector4 *)jarg1;
7935   result = (float) ((arg1)->q);
7936   jresult = result;
7937   return jresult;
7938 }
7939
7940
7941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7942   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7943
7944   arg1 = (Dali::Vector4 *)jarg1;
7945   {
7946     try {
7947       delete arg1;
7948     } catch (std::out_of_range& e) {
7949       {
7950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7951       };
7952     } catch (std::exception& e) {
7953       {
7954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7955       };
7956     } catch (...) {
7957       {
7958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7959       };
7960     }
7961   }
7962 }
7963
7964
7965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7966   void * jresult ;
7967   Dali::Vector4 *arg1 = 0 ;
7968   Dali::Vector4 *arg2 = 0 ;
7969   Dali::Vector4 result;
7970
7971   arg1 = (Dali::Vector4 *)jarg1;
7972   if (!arg1) {
7973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7974     return 0;
7975   }
7976   arg2 = (Dali::Vector4 *)jarg2;
7977   if (!arg2) {
7978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7979     return 0;
7980   }
7981   {
7982     try {
7983       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7984     } catch (std::out_of_range& e) {
7985       {
7986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7987       };
7988     } catch (std::exception& e) {
7989       {
7990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7991       };
7992     } catch (...) {
7993       {
7994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7995       };
7996     }
7997   }
7998   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7999   return jresult;
8000 }
8001
8002
8003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8004   void * jresult ;
8005   Dali::Vector4 *arg1 = 0 ;
8006   Dali::Vector4 *arg2 = 0 ;
8007   Dali::Vector4 result;
8008
8009   arg1 = (Dali::Vector4 *)jarg1;
8010   if (!arg1) {
8011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8012     return 0;
8013   }
8014   arg2 = (Dali::Vector4 *)jarg2;
8015   if (!arg2) {
8016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8017     return 0;
8018   }
8019   {
8020     try {
8021       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8022     } catch (std::out_of_range& e) {
8023       {
8024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8025       };
8026     } catch (std::exception& e) {
8027       {
8028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8029       };
8030     } catch (...) {
8031       {
8032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8033       };
8034     }
8035   }
8036   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8037   return jresult;
8038 }
8039
8040
8041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8042   void * jresult ;
8043   Dali::Vector4 *arg1 = 0 ;
8044   float *arg2 = 0 ;
8045   float *arg3 = 0 ;
8046   float temp2 ;
8047   float temp3 ;
8048   Dali::Vector4 result;
8049
8050   arg1 = (Dali::Vector4 *)jarg1;
8051   if (!arg1) {
8052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8053     return 0;
8054   }
8055   temp2 = (float)jarg2;
8056   arg2 = &temp2;
8057   temp3 = (float)jarg3;
8058   arg3 = &temp3;
8059   {
8060     try {
8061       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8062     } catch (std::out_of_range& e) {
8063       {
8064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8065       };
8066     } catch (std::exception& e) {
8067       {
8068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (...) {
8071       {
8072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8073       };
8074     }
8075   }
8076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8077   return jresult;
8078 }
8079
8080
8081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8082   void * jresult ;
8083   Dali::Uint16Pair *result = 0 ;
8084
8085   {
8086     try {
8087       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8088     } catch (std::out_of_range& e) {
8089       {
8090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8091       };
8092     } catch (std::exception& e) {
8093       {
8094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8095       };
8096     } catch (...) {
8097       {
8098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8099       };
8100     }
8101   }
8102   jresult = (void *)result;
8103   return jresult;
8104 }
8105
8106
8107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8108   void * jresult ;
8109   uint32_t arg1 ;
8110   uint32_t arg2 ;
8111   Dali::Uint16Pair *result = 0 ;
8112
8113   arg1 = (uint32_t)jarg1;
8114   arg2 = (uint32_t)jarg2;
8115   {
8116     try {
8117       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8118     } catch (std::out_of_range& e) {
8119       {
8120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8121       };
8122     } catch (std::exception& e) {
8123       {
8124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8125       };
8126     } catch (...) {
8127       {
8128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8129       };
8130     }
8131   }
8132   jresult = (void *)result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8138   void * jresult ;
8139   Dali::Uint16Pair *arg1 = 0 ;
8140   Dali::Uint16Pair *result = 0 ;
8141
8142   arg1 = (Dali::Uint16Pair *)jarg1;
8143   if (!arg1) {
8144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8145     return 0;
8146   }
8147   {
8148     try {
8149       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (...) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8161       };
8162     }
8163   }
8164   jresult = (void *)result;
8165   return jresult;
8166 }
8167
8168
8169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8170   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8171   uint16_t arg2 ;
8172
8173   arg1 = (Dali::Uint16Pair *)jarg1;
8174   arg2 = (uint16_t)jarg2;
8175   {
8176     try {
8177       (arg1)->SetWidth(arg2);
8178     } catch (std::out_of_range& e) {
8179       {
8180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8181       };
8182     } catch (std::exception& e) {
8183       {
8184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8185       };
8186     } catch (...) {
8187       {
8188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8189       };
8190     }
8191   }
8192 }
8193
8194
8195 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8196   unsigned short jresult ;
8197   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8198   uint16_t result;
8199
8200   arg1 = (Dali::Uint16Pair *)jarg1;
8201   {
8202     try {
8203       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8204     } catch (std::out_of_range& e) {
8205       {
8206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8207       };
8208     } catch (std::exception& e) {
8209       {
8210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8211       };
8212     } catch (...) {
8213       {
8214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8215       };
8216     }
8217   }
8218   jresult = result;
8219   return jresult;
8220 }
8221
8222
8223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8225   uint16_t arg2 ;
8226
8227   arg1 = (Dali::Uint16Pair *)jarg1;
8228   arg2 = (uint16_t)jarg2;
8229   {
8230     try {
8231       (arg1)->SetHeight(arg2);
8232     } catch (std::out_of_range& e) {
8233       {
8234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8235       };
8236     } catch (std::exception& e) {
8237       {
8238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8239       };
8240     } catch (...) {
8241       {
8242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8243       };
8244     }
8245   }
8246 }
8247
8248
8249 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8250   unsigned short jresult ;
8251   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8252   uint16_t result;
8253
8254   arg1 = (Dali::Uint16Pair *)jarg1;
8255   {
8256     try {
8257       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8258     } catch (std::out_of_range& e) {
8259       {
8260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8261       };
8262     } catch (std::exception& e) {
8263       {
8264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8265       };
8266     } catch (...) {
8267       {
8268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8269       };
8270     }
8271   }
8272   jresult = result;
8273   return jresult;
8274 }
8275
8276
8277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8278   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8279   uint16_t arg2 ;
8280
8281   arg1 = (Dali::Uint16Pair *)jarg1;
8282   arg2 = (uint16_t)jarg2;
8283   {
8284     try {
8285       (arg1)->SetX(arg2);
8286     } catch (std::out_of_range& e) {
8287       {
8288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8289       };
8290     } catch (std::exception& e) {
8291       {
8292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8293       };
8294     } catch (...) {
8295       {
8296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8297       };
8298     }
8299   }
8300 }
8301
8302
8303 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8304   unsigned short jresult ;
8305   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8306   uint16_t result;
8307
8308   arg1 = (Dali::Uint16Pair *)jarg1;
8309   {
8310     try {
8311       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8312     } catch (std::out_of_range& e) {
8313       {
8314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8315       };
8316     } catch (std::exception& e) {
8317       {
8318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8319       };
8320     } catch (...) {
8321       {
8322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8323       };
8324     }
8325   }
8326   jresult = result;
8327   return jresult;
8328 }
8329
8330
8331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8332   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8333   uint16_t arg2 ;
8334
8335   arg1 = (Dali::Uint16Pair *)jarg1;
8336   arg2 = (uint16_t)jarg2;
8337   {
8338     try {
8339       (arg1)->SetY(arg2);
8340     } catch (std::out_of_range& e) {
8341       {
8342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8343       };
8344     } catch (std::exception& e) {
8345       {
8346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8347       };
8348     } catch (...) {
8349       {
8350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8351       };
8352     }
8353   }
8354 }
8355
8356
8357 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8358   unsigned short jresult ;
8359   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8360   uint16_t result;
8361
8362   arg1 = (Dali::Uint16Pair *)jarg1;
8363   {
8364     try {
8365       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8366     } catch (std::out_of_range& e) {
8367       {
8368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8369       };
8370     } catch (std::exception& e) {
8371       {
8372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (...) {
8375       {
8376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8377       };
8378     }
8379   }
8380   jresult = result;
8381   return jresult;
8382 }
8383
8384
8385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8386   void * jresult ;
8387   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8388   Dali::Uint16Pair *arg2 = 0 ;
8389   Dali::Uint16Pair *result = 0 ;
8390
8391   arg1 = (Dali::Uint16Pair *)jarg1;
8392   arg2 = (Dali::Uint16Pair *)jarg2;
8393   if (!arg2) {
8394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8395     return 0;
8396   }
8397   {
8398     try {
8399       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8400     } catch (std::out_of_range& e) {
8401       {
8402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8403       };
8404     } catch (std::exception& e) {
8405       {
8406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8407       };
8408     } catch (...) {
8409       {
8410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8411       };
8412     }
8413   }
8414   jresult = (void *)result;
8415   return jresult;
8416 }
8417
8418
8419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8420   unsigned int jresult ;
8421   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8422   Dali::Uint16Pair *arg2 = 0 ;
8423   bool result;
8424
8425   arg1 = (Dali::Uint16Pair *)jarg1;
8426   arg2 = (Dali::Uint16Pair *)jarg2;
8427   if (!arg2) {
8428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8429     return 0;
8430   }
8431   {
8432     try {
8433       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8441       };
8442     } catch (...) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8445       };
8446     }
8447   }
8448   jresult = result;
8449   return jresult;
8450 }
8451
8452
8453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8454   unsigned int jresult ;
8455   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8456   Dali::Uint16Pair *arg2 = 0 ;
8457   bool result;
8458
8459   arg1 = (Dali::Uint16Pair *)jarg1;
8460   arg2 = (Dali::Uint16Pair *)jarg2;
8461   if (!arg2) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8463     return 0;
8464   }
8465   {
8466     try {
8467       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8468     } catch (std::out_of_range& e) {
8469       {
8470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8471       };
8472     } catch (std::exception& e) {
8473       {
8474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8475       };
8476     } catch (...) {
8477       {
8478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8479       };
8480     }
8481   }
8482   jresult = result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8488   unsigned int jresult ;
8489   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8490   Dali::Uint16Pair *arg2 = 0 ;
8491   bool result;
8492
8493   arg1 = (Dali::Uint16Pair *)jarg1;
8494   arg2 = (Dali::Uint16Pair *)jarg2;
8495   if (!arg2) {
8496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8497     return 0;
8498   }
8499   {
8500     try {
8501       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8502     } catch (std::out_of_range& e) {
8503       {
8504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8505       };
8506     } catch (std::exception& e) {
8507       {
8508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8509       };
8510     } catch (...) {
8511       {
8512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8513       };
8514     }
8515   }
8516   jresult = result;
8517   return jresult;
8518 }
8519
8520
8521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8522   unsigned int jresult ;
8523   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8524   Dali::Uint16Pair *arg2 = 0 ;
8525   bool result;
8526
8527   arg1 = (Dali::Uint16Pair *)jarg1;
8528   arg2 = (Dali::Uint16Pair *)jarg2;
8529   if (!arg2) {
8530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8531     return 0;
8532   }
8533   {
8534     try {
8535       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8536     } catch (std::out_of_range& e) {
8537       {
8538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8539       };
8540     } catch (std::exception& e) {
8541       {
8542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8543       };
8544     } catch (...) {
8545       {
8546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8547       };
8548     }
8549   }
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8556   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8557
8558   arg1 = (Dali::Uint16Pair *)jarg1;
8559   {
8560     try {
8561       delete arg1;
8562     } catch (std::out_of_range& e) {
8563       {
8564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8565       };
8566     } catch (std::exception& e) {
8567       {
8568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8569       };
8570     } catch (...) {
8571       {
8572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8573       };
8574     }
8575   }
8576 }
8577
8578
8579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8580   void * jresult ;
8581   Dali::Degree *result = 0 ;
8582
8583   {
8584     try {
8585       result = (Dali::Degree *)new Dali::Degree();
8586     } catch (std::out_of_range& e) {
8587       {
8588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8589       };
8590     } catch (std::exception& e) {
8591       {
8592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8593       };
8594     } catch (...) {
8595       {
8596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8597       };
8598     }
8599   }
8600   jresult = (void *)result;
8601   return jresult;
8602 }
8603
8604
8605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8606   void * jresult ;
8607   float arg1 ;
8608   Dali::Degree *result = 0 ;
8609
8610   arg1 = (float)jarg1;
8611   {
8612     try {
8613       result = (Dali::Degree *)new Dali::Degree(arg1);
8614     } catch (std::out_of_range& e) {
8615       {
8616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8617       };
8618     } catch (std::exception& e) {
8619       {
8620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8621       };
8622     } catch (...) {
8623       {
8624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8625       };
8626     }
8627   }
8628   jresult = (void *)result;
8629   return jresult;
8630 }
8631
8632
8633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8634   void * jresult ;
8635   Dali::Radian arg1 ;
8636   Dali::Radian *argp1 ;
8637   Dali::Degree *result = 0 ;
8638
8639   argp1 = (Dali::Radian *)jarg1;
8640   if (!argp1) {
8641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8642     return 0;
8643   }
8644   arg1 = *argp1;
8645   {
8646     try {
8647       result = (Dali::Degree *)new Dali::Degree(arg1);
8648     } catch (std::out_of_range& e) {
8649       {
8650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8651       };
8652     } catch (std::exception& e) {
8653       {
8654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8655       };
8656     } catch (...) {
8657       {
8658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8659       };
8660     }
8661   }
8662   jresult = (void *)result;
8663   return jresult;
8664 }
8665
8666
8667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8668   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8669   float arg2 ;
8670
8671   arg1 = (Dali::Degree *)jarg1;
8672   arg2 = (float)jarg2;
8673   if (arg1) (arg1)->degree = arg2;
8674 }
8675
8676
8677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8678   float jresult ;
8679   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8680   float result;
8681
8682   arg1 = (Dali::Degree *)jarg1;
8683   result = (float) ((arg1)->degree);
8684   jresult = result;
8685   return jresult;
8686 }
8687
8688
8689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8690   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8691
8692   arg1 = (Dali::Degree *)jarg1;
8693   {
8694     try {
8695       delete arg1;
8696     } catch (std::out_of_range& e) {
8697       {
8698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8699       };
8700     } catch (std::exception& e) {
8701       {
8702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8703       };
8704     } catch (...) {
8705       {
8706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8707       };
8708     }
8709   }
8710 }
8711
8712
8713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8714   void * jresult ;
8715   Dali::Radian *result = 0 ;
8716
8717   result = (Dali::Radian *)&Dali::ANGLE_360;
8718   jresult = (void *)result;
8719   return jresult;
8720 }
8721
8722
8723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8724   void * jresult ;
8725   Dali::Radian *result = 0 ;
8726
8727   result = (Dali::Radian *)&Dali::ANGLE_315;
8728   jresult = (void *)result;
8729   return jresult;
8730 }
8731
8732
8733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8734   void * jresult ;
8735   Dali::Radian *result = 0 ;
8736
8737   result = (Dali::Radian *)&Dali::ANGLE_270;
8738   jresult = (void *)result;
8739   return jresult;
8740 }
8741
8742
8743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8744   void * jresult ;
8745   Dali::Radian *result = 0 ;
8746
8747   result = (Dali::Radian *)&Dali::ANGLE_225;
8748   jresult = (void *)result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8754   void * jresult ;
8755   Dali::Radian *result = 0 ;
8756
8757   result = (Dali::Radian *)&Dali::ANGLE_180;
8758   jresult = (void *)result;
8759   return jresult;
8760 }
8761
8762
8763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8764   void * jresult ;
8765   Dali::Radian *result = 0 ;
8766
8767   result = (Dali::Radian *)&Dali::ANGLE_135;
8768   jresult = (void *)result;
8769   return jresult;
8770 }
8771
8772
8773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8774   void * jresult ;
8775   Dali::Radian *result = 0 ;
8776
8777   result = (Dali::Radian *)&Dali::ANGLE_120;
8778   jresult = (void *)result;
8779   return jresult;
8780 }
8781
8782
8783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8784   void * jresult ;
8785   Dali::Radian *result = 0 ;
8786
8787   result = (Dali::Radian *)&Dali::ANGLE_90;
8788   jresult = (void *)result;
8789   return jresult;
8790 }
8791
8792
8793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8794   void * jresult ;
8795   Dali::Radian *result = 0 ;
8796
8797   result = (Dali::Radian *)&Dali::ANGLE_60;
8798   jresult = (void *)result;
8799   return jresult;
8800 }
8801
8802
8803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8804   void * jresult ;
8805   Dali::Radian *result = 0 ;
8806
8807   result = (Dali::Radian *)&Dali::ANGLE_45;
8808   jresult = (void *)result;
8809   return jresult;
8810 }
8811
8812
8813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8814   void * jresult ;
8815   Dali::Radian *result = 0 ;
8816
8817   result = (Dali::Radian *)&Dali::ANGLE_30;
8818   jresult = (void *)result;
8819   return jresult;
8820 }
8821
8822
8823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8824   void * jresult ;
8825   Dali::Radian *result = 0 ;
8826
8827   result = (Dali::Radian *)&Dali::ANGLE_0;
8828   jresult = (void *)result;
8829   return jresult;
8830 }
8831
8832
8833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8834   unsigned int jresult ;
8835   Dali::Degree *arg1 = 0 ;
8836   Dali::Degree *arg2 = 0 ;
8837   bool result;
8838
8839   arg1 = (Dali::Degree *)jarg1;
8840   if (!arg1) {
8841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8842     return 0;
8843   }
8844   arg2 = (Dali::Degree *)jarg2;
8845   if (!arg2) {
8846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8847     return 0;
8848   }
8849   {
8850     try {
8851       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8852     } catch (std::out_of_range& e) {
8853       {
8854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (std::exception& e) {
8857       {
8858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866   jresult = result;
8867   return jresult;
8868 }
8869
8870
8871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8872   unsigned int jresult ;
8873   Dali::Degree *arg1 = 0 ;
8874   Dali::Degree *arg2 = 0 ;
8875   bool result;
8876
8877   arg1 = (Dali::Degree *)jarg1;
8878   if (!arg1) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8880     return 0;
8881   }
8882   arg2 = (Dali::Degree *)jarg2;
8883   if (!arg2) {
8884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8885     return 0;
8886   }
8887   {
8888     try {
8889       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8890     } catch (std::out_of_range& e) {
8891       {
8892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8893       };
8894     } catch (std::exception& e) {
8895       {
8896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8897       };
8898     } catch (...) {
8899       {
8900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8901       };
8902     }
8903   }
8904   jresult = result;
8905   return jresult;
8906 }
8907
8908
8909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8910   void * jresult ;
8911   Dali::Degree arg1 ;
8912   float arg2 ;
8913   float arg3 ;
8914   Dali::Degree *argp1 ;
8915   Dali::Degree result;
8916
8917   argp1 = (Dali::Degree *)jarg1;
8918   if (!argp1) {
8919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8920     return 0;
8921   }
8922   arg1 = *argp1;
8923   arg2 = (float)jarg2;
8924   arg3 = (float)jarg3;
8925   {
8926     try {
8927       result = Dali::Clamp(arg1,arg2,arg3);
8928     } catch (std::out_of_range& e) {
8929       {
8930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8931       };
8932     } catch (std::exception& e) {
8933       {
8934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8935       };
8936     } catch (...) {
8937       {
8938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8939       };
8940     }
8941   }
8942   jresult = new Dali::Degree((const Dali::Degree &)result);
8943   return jresult;
8944 }
8945
8946
8947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8948   void * jresult ;
8949   Dali::Radian *result = 0 ;
8950
8951   {
8952     try {
8953       result = (Dali::Radian *)new Dali::Radian();
8954     } catch (std::out_of_range& e) {
8955       {
8956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8957       };
8958     } catch (std::exception& e) {
8959       {
8960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8961       };
8962     } catch (...) {
8963       {
8964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8965       };
8966     }
8967   }
8968   jresult = (void *)result;
8969   return jresult;
8970 }
8971
8972
8973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8974   void * jresult ;
8975   float arg1 ;
8976   Dali::Radian *result = 0 ;
8977
8978   arg1 = (float)jarg1;
8979   {
8980     try {
8981       result = (Dali::Radian *)new Dali::Radian(arg1);
8982     } catch (std::out_of_range& e) {
8983       {
8984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8985       };
8986     } catch (std::exception& e) {
8987       {
8988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8989       };
8990     } catch (...) {
8991       {
8992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8993       };
8994     }
8995   }
8996   jresult = (void *)result;
8997   return jresult;
8998 }
8999
9000
9001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9002   void * jresult ;
9003   Dali::Degree arg1 ;
9004   Dali::Degree *argp1 ;
9005   Dali::Radian *result = 0 ;
9006
9007   argp1 = (Dali::Degree *)jarg1;
9008   if (!argp1) {
9009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9010     return 0;
9011   }
9012   arg1 = *argp1;
9013   {
9014     try {
9015       result = (Dali::Radian *)new Dali::Radian(arg1);
9016     } catch (std::out_of_range& e) {
9017       {
9018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9019       };
9020     } catch (std::exception& e) {
9021       {
9022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9023       };
9024     } catch (...) {
9025       {
9026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9027       };
9028     }
9029   }
9030   jresult = (void *)result;
9031   return jresult;
9032 }
9033
9034
9035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9036   void * jresult ;
9037   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9038   float arg2 ;
9039   Dali::Radian *result = 0 ;
9040
9041   arg1 = (Dali::Radian *)jarg1;
9042   arg2 = (float)jarg2;
9043   {
9044     try {
9045       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9046     } catch (std::out_of_range& e) {
9047       {
9048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9049       };
9050     } catch (std::exception& e) {
9051       {
9052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9053       };
9054     } catch (...) {
9055       {
9056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9057       };
9058     }
9059   }
9060   jresult = (void *)result;
9061   return jresult;
9062 }
9063
9064
9065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9066   void * jresult ;
9067   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9068   Dali::Degree arg2 ;
9069   Dali::Degree *argp2 ;
9070   Dali::Radian *result = 0 ;
9071
9072   arg1 = (Dali::Radian *)jarg1;
9073   argp2 = (Dali::Degree *)jarg2;
9074   if (!argp2) {
9075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9076     return 0;
9077   }
9078   arg2 = *argp2;
9079   {
9080     try {
9081       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9082     } catch (std::out_of_range& e) {
9083       {
9084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9085       };
9086     } catch (std::exception& e) {
9087       {
9088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9089       };
9090     } catch (...) {
9091       {
9092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9093       };
9094     }
9095   }
9096   jresult = (void *)result;
9097   return jresult;
9098 }
9099
9100
9101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9102   float jresult ;
9103   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9104   float result;
9105
9106   arg1 = (Dali::Radian *)jarg1;
9107   {
9108     try {
9109       result = (float)((Dali::Radian const *)arg1)->operator float();
9110     } catch (std::out_of_range& e) {
9111       {
9112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9113       };
9114     } catch (std::exception& e) {
9115       {
9116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9117       };
9118     } catch (...) {
9119       {
9120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9121       };
9122     }
9123   }
9124   jresult = result;
9125   return jresult;
9126 }
9127
9128
9129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9130   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9131   float arg2 ;
9132
9133   arg1 = (Dali::Radian *)jarg1;
9134   arg2 = (float)jarg2;
9135   if (arg1) (arg1)->radian = arg2;
9136 }
9137
9138
9139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9140   float jresult ;
9141   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9142   float result;
9143
9144   arg1 = (Dali::Radian *)jarg1;
9145   result = (float) ((arg1)->radian);
9146   jresult = result;
9147   return jresult;
9148 }
9149
9150
9151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9152   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9153
9154   arg1 = (Dali::Radian *)jarg1;
9155   {
9156     try {
9157       delete arg1;
9158     } catch (std::out_of_range& e) {
9159       {
9160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9161       };
9162     } catch (std::exception& e) {
9163       {
9164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9165       };
9166     } catch (...) {
9167       {
9168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9169       };
9170     }
9171   }
9172 }
9173
9174
9175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9176   unsigned int jresult ;
9177   Dali::Radian arg1 ;
9178   Dali::Radian arg2 ;
9179   Dali::Radian *argp1 ;
9180   Dali::Radian *argp2 ;
9181   bool result;
9182
9183   argp1 = (Dali::Radian *)jarg1;
9184   if (!argp1) {
9185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9186     return 0;
9187   }
9188   arg1 = *argp1;
9189   argp2 = (Dali::Radian *)jarg2;
9190   if (!argp2) {
9191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9192     return 0;
9193   }
9194   arg2 = *argp2;
9195   {
9196     try {
9197       result = (bool)Dali::operator ==(arg1,arg2);
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9205       };
9206     } catch (...) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9209       };
9210     }
9211   }
9212   jresult = result;
9213   return jresult;
9214 }
9215
9216
9217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9218   unsigned int jresult ;
9219   Dali::Radian arg1 ;
9220   Dali::Radian arg2 ;
9221   Dali::Radian *argp1 ;
9222   Dali::Radian *argp2 ;
9223   bool result;
9224
9225   argp1 = (Dali::Radian *)jarg1;
9226   if (!argp1) {
9227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9228     return 0;
9229   }
9230   arg1 = *argp1;
9231   argp2 = (Dali::Radian *)jarg2;
9232   if (!argp2) {
9233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9234     return 0;
9235   }
9236   arg2 = *argp2;
9237   {
9238     try {
9239       result = (bool)Dali::operator !=(arg1,arg2);
9240     } catch (std::out_of_range& e) {
9241       {
9242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9243       };
9244     } catch (std::exception& e) {
9245       {
9246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9247       };
9248     } catch (...) {
9249       {
9250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9251       };
9252     }
9253   }
9254   jresult = result;
9255   return jresult;
9256 }
9257
9258
9259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9260   unsigned int jresult ;
9261   Dali::Radian arg1 ;
9262   Dali::Degree arg2 ;
9263   Dali::Radian *argp1 ;
9264   Dali::Degree *argp2 ;
9265   bool result;
9266
9267   argp1 = (Dali::Radian *)jarg1;
9268   if (!argp1) {
9269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9270     return 0;
9271   }
9272   arg1 = *argp1;
9273   argp2 = (Dali::Degree *)jarg2;
9274   if (!argp2) {
9275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9276     return 0;
9277   }
9278   arg2 = *argp2;
9279   {
9280     try {
9281       result = (bool)Dali::operator ==(arg1,arg2);
9282     } catch (std::out_of_range& e) {
9283       {
9284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9285       };
9286     } catch (std::exception& e) {
9287       {
9288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9289       };
9290     } catch (...) {
9291       {
9292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9293       };
9294     }
9295   }
9296   jresult = result;
9297   return jresult;
9298 }
9299
9300
9301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9302   unsigned int jresult ;
9303   Dali::Radian arg1 ;
9304   Dali::Degree arg2 ;
9305   Dali::Radian *argp1 ;
9306   Dali::Degree *argp2 ;
9307   bool result;
9308
9309   argp1 = (Dali::Radian *)jarg1;
9310   if (!argp1) {
9311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9312     return 0;
9313   }
9314   arg1 = *argp1;
9315   argp2 = (Dali::Degree *)jarg2;
9316   if (!argp2) {
9317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9318     return 0;
9319   }
9320   arg2 = *argp2;
9321   {
9322     try {
9323       result = (bool)Dali::operator !=(arg1,arg2);
9324     } catch (std::out_of_range& e) {
9325       {
9326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9327       };
9328     } catch (std::exception& e) {
9329       {
9330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (...) {
9333       {
9334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9335       };
9336     }
9337   }
9338   jresult = result;
9339   return jresult;
9340 }
9341
9342
9343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9344   unsigned int jresult ;
9345   Dali::Degree arg1 ;
9346   Dali::Radian arg2 ;
9347   Dali::Degree *argp1 ;
9348   Dali::Radian *argp2 ;
9349   bool result;
9350
9351   argp1 = (Dali::Degree *)jarg1;
9352   if (!argp1) {
9353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9354     return 0;
9355   }
9356   arg1 = *argp1;
9357   argp2 = (Dali::Radian *)jarg2;
9358   if (!argp2) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9360     return 0;
9361   }
9362   arg2 = *argp2;
9363   {
9364     try {
9365       result = (bool)Dali::operator ==(arg1,arg2);
9366     } catch (std::out_of_range& e) {
9367       {
9368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9369       };
9370     } catch (std::exception& e) {
9371       {
9372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (...) {
9375       {
9376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9377       };
9378     }
9379   }
9380   jresult = result;
9381   return jresult;
9382 }
9383
9384
9385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9386   unsigned int jresult ;
9387   Dali::Degree arg1 ;
9388   Dali::Radian arg2 ;
9389   Dali::Degree *argp1 ;
9390   Dali::Radian *argp2 ;
9391   bool result;
9392
9393   argp1 = (Dali::Degree *)jarg1;
9394   if (!argp1) {
9395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9396     return 0;
9397   }
9398   arg1 = *argp1;
9399   argp2 = (Dali::Radian *)jarg2;
9400   if (!argp2) {
9401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9402     return 0;
9403   }
9404   arg2 = *argp2;
9405   {
9406     try {
9407       result = (bool)Dali::operator !=(arg1,arg2);
9408     } catch (std::out_of_range& e) {
9409       {
9410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (std::exception& e) {
9413       {
9414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (...) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9419       };
9420     }
9421   }
9422   jresult = result;
9423   return jresult;
9424 }
9425
9426
9427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9428   unsigned int jresult ;
9429   Dali::Radian arg1 ;
9430   Dali::Radian arg2 ;
9431   Dali::Radian *argp1 ;
9432   Dali::Radian *argp2 ;
9433   bool result;
9434
9435   argp1 = (Dali::Radian *)jarg1;
9436   if (!argp1) {
9437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9438     return 0;
9439   }
9440   arg1 = *argp1;
9441   argp2 = (Dali::Radian *)jarg2;
9442   if (!argp2) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9444     return 0;
9445   }
9446   arg2 = *argp2;
9447   {
9448     try {
9449       result = (bool)Dali::operator >(arg1,arg2);
9450     } catch (std::out_of_range& e) {
9451       {
9452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9453       };
9454     } catch (std::exception& e) {
9455       {
9456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9457       };
9458     } catch (...) {
9459       {
9460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9461       };
9462     }
9463   }
9464   jresult = result;
9465   return jresult;
9466 }
9467
9468
9469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9470   unsigned int jresult ;
9471   Dali::Radian arg1 ;
9472   Dali::Degree arg2 ;
9473   Dali::Radian *argp1 ;
9474   Dali::Degree *argp2 ;
9475   bool result;
9476
9477   argp1 = (Dali::Radian *)jarg1;
9478   if (!argp1) {
9479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9480     return 0;
9481   }
9482   arg1 = *argp1;
9483   argp2 = (Dali::Degree *)jarg2;
9484   if (!argp2) {
9485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9486     return 0;
9487   }
9488   arg2 = *argp2;
9489   {
9490     try {
9491       result = (bool)Dali::operator >(arg1,arg2);
9492     } catch (std::out_of_range& e) {
9493       {
9494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9495       };
9496     } catch (std::exception& e) {
9497       {
9498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9503       };
9504     }
9505   }
9506   jresult = result;
9507   return jresult;
9508 }
9509
9510
9511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9512   unsigned int jresult ;
9513   Dali::Degree arg1 ;
9514   Dali::Radian arg2 ;
9515   Dali::Degree *argp1 ;
9516   Dali::Radian *argp2 ;
9517   bool result;
9518
9519   argp1 = (Dali::Degree *)jarg1;
9520   if (!argp1) {
9521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9522     return 0;
9523   }
9524   arg1 = *argp1;
9525   argp2 = (Dali::Radian *)jarg2;
9526   if (!argp2) {
9527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9528     return 0;
9529   }
9530   arg2 = *argp2;
9531   {
9532     try {
9533       result = (bool)Dali::operator >(arg1,arg2);
9534     } catch (std::out_of_range& e) {
9535       {
9536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9537       };
9538     } catch (std::exception& e) {
9539       {
9540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9541       };
9542     } catch (...) {
9543       {
9544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9545       };
9546     }
9547   }
9548   jresult = result;
9549   return jresult;
9550 }
9551
9552
9553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9554   unsigned int jresult ;
9555   Dali::Radian arg1 ;
9556   Dali::Radian arg2 ;
9557   Dali::Radian *argp1 ;
9558   Dali::Radian *argp2 ;
9559   bool result;
9560
9561   argp1 = (Dali::Radian *)jarg1;
9562   if (!argp1) {
9563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9564     return 0;
9565   }
9566   arg1 = *argp1;
9567   argp2 = (Dali::Radian *)jarg2;
9568   if (!argp2) {
9569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9570     return 0;
9571   }
9572   arg2 = *argp2;
9573   {
9574     try {
9575       result = (bool)Dali::operator <(arg1,arg2);
9576     } catch (std::out_of_range& e) {
9577       {
9578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9579       };
9580     } catch (std::exception& e) {
9581       {
9582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (...) {
9585       {
9586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9587       };
9588     }
9589   }
9590   jresult = result;
9591   return jresult;
9592 }
9593
9594
9595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9596   unsigned int jresult ;
9597   Dali::Radian arg1 ;
9598   Dali::Degree arg2 ;
9599   Dali::Radian *argp1 ;
9600   Dali::Degree *argp2 ;
9601   bool result;
9602
9603   argp1 = (Dali::Radian *)jarg1;
9604   if (!argp1) {
9605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9606     return 0;
9607   }
9608   arg1 = *argp1;
9609   argp2 = (Dali::Degree *)jarg2;
9610   if (!argp2) {
9611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9612     return 0;
9613   }
9614   arg2 = *argp2;
9615   {
9616     try {
9617       result = (bool)Dali::operator <(arg1,arg2);
9618     } catch (std::out_of_range& e) {
9619       {
9620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (std::exception& e) {
9623       {
9624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (...) {
9627       {
9628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9629       };
9630     }
9631   }
9632   jresult = result;
9633   return jresult;
9634 }
9635
9636
9637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9638   unsigned int jresult ;
9639   Dali::Degree arg1 ;
9640   Dali::Radian arg2 ;
9641   Dali::Degree *argp1 ;
9642   Dali::Radian *argp2 ;
9643   bool result;
9644
9645   argp1 = (Dali::Degree *)jarg1;
9646   if (!argp1) {
9647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9648     return 0;
9649   }
9650   arg1 = *argp1;
9651   argp2 = (Dali::Radian *)jarg2;
9652   if (!argp2) {
9653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9654     return 0;
9655   }
9656   arg2 = *argp2;
9657   {
9658     try {
9659       result = (bool)Dali::operator <(arg1,arg2);
9660     } catch (std::out_of_range& e) {
9661       {
9662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9663       };
9664     } catch (std::exception& e) {
9665       {
9666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9667       };
9668     } catch (...) {
9669       {
9670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9671       };
9672     }
9673   }
9674   jresult = result;
9675   return jresult;
9676 }
9677
9678
9679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9680   void * jresult ;
9681   Dali::Radian arg1 ;
9682   float arg2 ;
9683   Dali::Radian *argp1 ;
9684   Dali::Radian result;
9685
9686   argp1 = (Dali::Radian *)jarg1;
9687   if (!argp1) {
9688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9689     return 0;
9690   }
9691   arg1 = *argp1;
9692   arg2 = (float)jarg2;
9693   {
9694     try {
9695       result = Dali::operator *(arg1,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 (...) {
9705       {
9706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9707       };
9708     }
9709   }
9710   jresult = new Dali::Radian((const Dali::Radian &)result);
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9716   void * jresult ;
9717   Dali::Radian arg1 ;
9718   Dali::Radian *argp1 ;
9719   Dali::Radian result;
9720
9721   argp1 = (Dali::Radian *)jarg1;
9722   if (!argp1) {
9723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9724     return 0;
9725   }
9726   arg1 = *argp1;
9727   {
9728     try {
9729       result = Dali::operator -(arg1);
9730     } catch (std::out_of_range& e) {
9731       {
9732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9733       };
9734     } catch (std::exception& e) {
9735       {
9736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9737       };
9738     } catch (...) {
9739       {
9740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9741       };
9742     }
9743   }
9744   jresult = new Dali::Radian((const Dali::Radian &)result);
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9750   void * jresult ;
9751   Dali::Radian arg1 ;
9752   float arg2 ;
9753   float arg3 ;
9754   Dali::Radian *argp1 ;
9755   Dali::Radian result;
9756
9757   argp1 = (Dali::Radian *)jarg1;
9758   if (!argp1) {
9759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9760     return 0;
9761   }
9762   arg1 = *argp1;
9763   arg2 = (float)jarg2;
9764   arg3 = (float)jarg3;
9765   {
9766     try {
9767       result = Dali::Clamp(arg1,arg2,arg3);
9768     } catch (std::out_of_range& e) {
9769       {
9770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9771       };
9772     } catch (std::exception& e) {
9773       {
9774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9775       };
9776     } catch (...) {
9777       {
9778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9779       };
9780     }
9781   }
9782   jresult = new Dali::Radian((const Dali::Radian &)result);
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9788   void * jresult ;
9789   Dali::Quaternion *result = 0 ;
9790
9791   {
9792     try {
9793       result = (Dali::Quaternion *)new Dali::Quaternion();
9794     } catch (std::out_of_range& e) {
9795       {
9796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9797       };
9798     } catch (std::exception& e) {
9799       {
9800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9801       };
9802     } catch (...) {
9803       {
9804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9805       };
9806     }
9807   }
9808   jresult = (void *)result;
9809   return jresult;
9810 }
9811
9812
9813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9814   void * jresult ;
9815   Dali::Radian arg1 ;
9816   Dali::Vector3 *arg2 = 0 ;
9817   Dali::Radian *argp1 ;
9818   Dali::Quaternion *result = 0 ;
9819
9820   argp1 = (Dali::Radian *)jarg1;
9821   if (!argp1) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9823     return 0;
9824   }
9825   arg1 = *argp1;
9826   arg2 = (Dali::Vector3 *)jarg2;
9827   if (!arg2) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9829     return 0;
9830   }
9831   {
9832     try {
9833       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9834     } catch (std::out_of_range& e) {
9835       {
9836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (std::exception& e) {
9839       {
9840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (...) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9845       };
9846     }
9847   }
9848   jresult = (void *)result;
9849   return jresult;
9850 }
9851
9852
9853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9854   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9855
9856   arg1 = (Dali::Quaternion *)jarg1;
9857   {
9858     try {
9859       delete arg1;
9860     } catch (std::out_of_range& e) {
9861       {
9862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9863       };
9864     } catch (std::exception& e) {
9865       {
9866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9867       };
9868     } catch (...) {
9869       {
9870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9871       };
9872     }
9873   }
9874 }
9875
9876
9877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9878   void * jresult ;
9879   Dali::Quaternion *result = 0 ;
9880
9881   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9882   jresult = (void *)result;
9883   return jresult;
9884 }
9885
9886
9887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9888   unsigned int jresult ;
9889   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9890   bool result;
9891
9892   arg1 = (Dali::Quaternion *)jarg1;
9893   {
9894     try {
9895       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9896     } catch (std::out_of_range& e) {
9897       {
9898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9899       };
9900     } catch (std::exception& e) {
9901       {
9902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9903       };
9904     } catch (...) {
9905       {
9906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9907       };
9908     }
9909   }
9910   jresult = result;
9911   return jresult;
9912 }
9913
9914
9915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9916   unsigned int jresult ;
9917   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9918   Dali::Vector3 *arg2 = 0 ;
9919   Dali::Radian *arg3 = 0 ;
9920   bool result;
9921
9922   arg1 = (Dali::Quaternion *)jarg1;
9923   arg2 = (Dali::Vector3 *)jarg2;
9924   if (!arg2) {
9925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9926     return 0;
9927   }
9928   arg3 = (Dali::Radian *)jarg3;
9929   if (!arg3) {
9930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9931     return 0;
9932   }
9933   {
9934     try {
9935       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9936     } catch (std::out_of_range& e) {
9937       {
9938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9939       };
9940     } catch (std::exception& e) {
9941       {
9942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (...) {
9945       {
9946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9947       };
9948     }
9949   }
9950   jresult = result;
9951   return jresult;
9952 }
9953
9954
9955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9956   void * jresult ;
9957   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9958   Dali::Quaternion *arg2 = 0 ;
9959   Dali::Quaternion result;
9960
9961   arg1 = (Dali::Quaternion *)jarg1;
9962   arg2 = (Dali::Quaternion *)jarg2;
9963   if (!arg2) {
9964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9965     return 0;
9966   }
9967   {
9968     try {
9969       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9970     } catch (std::out_of_range& e) {
9971       {
9972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9973       };
9974     } catch (std::exception& e) {
9975       {
9976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (...) {
9979       {
9980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9981       };
9982     }
9983   }
9984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9985   return jresult;
9986 }
9987
9988
9989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9990   void * jresult ;
9991   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9992   Dali::Quaternion *arg2 = 0 ;
9993   Dali::Quaternion result;
9994
9995   arg1 = (Dali::Quaternion *)jarg1;
9996   arg2 = (Dali::Quaternion *)jarg2;
9997   if (!arg2) {
9998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9999     return 0;
10000   }
10001   {
10002     try {
10003       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10004     } catch (std::out_of_range& e) {
10005       {
10006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10007       };
10008     } catch (std::exception& e) {
10009       {
10010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10011       };
10012     } catch (...) {
10013       {
10014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10015       };
10016     }
10017   }
10018   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10019   return jresult;
10020 }
10021
10022
10023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10024   void * jresult ;
10025   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10026   Dali::Quaternion *arg2 = 0 ;
10027   Dali::Quaternion result;
10028
10029   arg1 = (Dali::Quaternion *)jarg1;
10030   arg2 = (Dali::Quaternion *)jarg2;
10031   if (!arg2) {
10032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10033     return 0;
10034   }
10035   {
10036     try {
10037       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10038     } catch (std::out_of_range& e) {
10039       {
10040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10041       };
10042     } catch (std::exception& e) {
10043       {
10044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10045       };
10046     } catch (...) {
10047       {
10048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10049       };
10050     }
10051   }
10052   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10053   return jresult;
10054 }
10055
10056
10057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10058   void * jresult ;
10059   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10060   Dali::Vector3 *arg2 = 0 ;
10061   Dali::Vector3 result;
10062
10063   arg1 = (Dali::Quaternion *)jarg1;
10064   arg2 = (Dali::Vector3 *)jarg2;
10065   if (!arg2) {
10066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10067     return 0;
10068   }
10069   {
10070     try {
10071       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10072     } catch (std::out_of_range& e) {
10073       {
10074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10075       };
10076     } catch (std::exception& e) {
10077       {
10078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10079       };
10080     } catch (...) {
10081       {
10082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10083       };
10084     }
10085   }
10086   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10087   return jresult;
10088 }
10089
10090
10091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10092   void * jresult ;
10093   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10094   Dali::Quaternion *arg2 = 0 ;
10095   Dali::Quaternion result;
10096
10097   arg1 = (Dali::Quaternion *)jarg1;
10098   arg2 = (Dali::Quaternion *)jarg2;
10099   if (!arg2) {
10100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10101     return 0;
10102   }
10103   {
10104     try {
10105       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10106     } catch (std::out_of_range& e) {
10107       {
10108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10109       };
10110     } catch (std::exception& e) {
10111       {
10112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10113       };
10114     } catch (...) {
10115       {
10116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10117       };
10118     }
10119   }
10120   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10126   void * jresult ;
10127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10128   float arg2 ;
10129   Dali::Quaternion result;
10130
10131   arg1 = (Dali::Quaternion *)jarg1;
10132   arg2 = (float)jarg2;
10133   {
10134     try {
10135       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10136     } catch (std::out_of_range& e) {
10137       {
10138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (std::exception& e) {
10141       {
10142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10143       };
10144     } catch (...) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10147       };
10148     }
10149   }
10150   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10151   return jresult;
10152 }
10153
10154
10155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10156   void * jresult ;
10157   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10158   float arg2 ;
10159   Dali::Quaternion result;
10160
10161   arg1 = (Dali::Quaternion *)jarg1;
10162   arg2 = (float)jarg2;
10163   {
10164     try {
10165       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10166     } catch (std::out_of_range& e) {
10167       {
10168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10169       };
10170     } catch (std::exception& e) {
10171       {
10172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10173       };
10174     } catch (...) {
10175       {
10176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10177       };
10178     }
10179   }
10180   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10181   return jresult;
10182 }
10183
10184
10185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10186   void * jresult ;
10187   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10188   Dali::Quaternion result;
10189
10190   arg1 = (Dali::Quaternion *)jarg1;
10191   {
10192     try {
10193       result = ((Dali::Quaternion const *)arg1)->operator -();
10194     } catch (std::out_of_range& e) {
10195       {
10196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10197       };
10198     } catch (std::exception& e) {
10199       {
10200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10201       };
10202     } catch (...) {
10203       {
10204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10205       };
10206     }
10207   }
10208   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10209   return jresult;
10210 }
10211
10212
10213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10214   void * jresult ;
10215   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10216   Dali::Quaternion *arg2 = 0 ;
10217   Dali::Quaternion *result = 0 ;
10218
10219   arg1 = (Dali::Quaternion *)jarg1;
10220   arg2 = (Dali::Quaternion *)jarg2;
10221   if (!arg2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10223     return 0;
10224   }
10225   {
10226     try {
10227       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10228     } catch (std::out_of_range& e) {
10229       {
10230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (std::exception& e) {
10233       {
10234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (...) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10239       };
10240     }
10241   }
10242   jresult = (void *)result;
10243   return jresult;
10244 }
10245
10246
10247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10248   void * jresult ;
10249   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10250   Dali::Quaternion *arg2 = 0 ;
10251   Dali::Quaternion *result = 0 ;
10252
10253   arg1 = (Dali::Quaternion *)jarg1;
10254   arg2 = (Dali::Quaternion *)jarg2;
10255   if (!arg2) {
10256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10257     return 0;
10258   }
10259   {
10260     try {
10261       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10262     } catch (std::out_of_range& e) {
10263       {
10264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10265       };
10266     } catch (std::exception& e) {
10267       {
10268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10269       };
10270     } catch (...) {
10271       {
10272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10273       };
10274     }
10275   }
10276   jresult = (void *)result;
10277   return jresult;
10278 }
10279
10280
10281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10282   void * jresult ;
10283   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10284   Dali::Quaternion *arg2 = 0 ;
10285   Dali::Quaternion *result = 0 ;
10286
10287   arg1 = (Dali::Quaternion *)jarg1;
10288   arg2 = (Dali::Quaternion *)jarg2;
10289   if (!arg2) {
10290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10291     return 0;
10292   }
10293   {
10294     try {
10295       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10296     } catch (std::out_of_range& e) {
10297       {
10298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10299       };
10300     } catch (std::exception& e) {
10301       {
10302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10303       };
10304     } catch (...) {
10305       {
10306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10307       };
10308     }
10309   }
10310   jresult = (void *)result;
10311   return jresult;
10312 }
10313
10314
10315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10316   void * jresult ;
10317   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10318   float arg2 ;
10319   Dali::Quaternion *result = 0 ;
10320
10321   arg1 = (Dali::Quaternion *)jarg1;
10322   arg2 = (float)jarg2;
10323   {
10324     try {
10325       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (...) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10337       };
10338     }
10339   }
10340   jresult = (void *)result;
10341   return jresult;
10342 }
10343
10344
10345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10346   void * jresult ;
10347   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10348   float arg2 ;
10349   Dali::Quaternion *result = 0 ;
10350
10351   arg1 = (Dali::Quaternion *)jarg1;
10352   arg2 = (float)jarg2;
10353   {
10354     try {
10355       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10356     } catch (std::out_of_range& e) {
10357       {
10358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10359       };
10360     } catch (std::exception& e) {
10361       {
10362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10363       };
10364     } catch (...) {
10365       {
10366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10367       };
10368     }
10369   }
10370   jresult = (void *)result;
10371   return jresult;
10372 }
10373
10374
10375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10376   unsigned int jresult ;
10377   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10378   Dali::Quaternion *arg2 = 0 ;
10379   bool result;
10380
10381   arg1 = (Dali::Quaternion *)jarg1;
10382   arg2 = (Dali::Quaternion *)jarg2;
10383   if (!arg2) {
10384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10385     return 0;
10386   }
10387   {
10388     try {
10389       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10390     } catch (std::out_of_range& e) {
10391       {
10392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10393       };
10394     } catch (std::exception& e) {
10395       {
10396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10397       };
10398     } catch (...) {
10399       {
10400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10401       };
10402     }
10403   }
10404   jresult = result;
10405   return jresult;
10406 }
10407
10408
10409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10410   unsigned int jresult ;
10411   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10412   Dali::Quaternion *arg2 = 0 ;
10413   bool result;
10414
10415   arg1 = (Dali::Quaternion *)jarg1;
10416   arg2 = (Dali::Quaternion *)jarg2;
10417   if (!arg2) {
10418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10419     return 0;
10420   }
10421   {
10422     try {
10423       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10424     } catch (std::out_of_range& e) {
10425       {
10426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (std::exception& e) {
10429       {
10430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438   jresult = result;
10439   return jresult;
10440 }
10441
10442
10443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10444   float jresult ;
10445   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10446   float result;
10447
10448   arg1 = (Dali::Quaternion *)jarg1;
10449   {
10450     try {
10451       result = (float)((Dali::Quaternion const *)arg1)->Length();
10452     } catch (std::out_of_range& e) {
10453       {
10454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10455       };
10456     } catch (std::exception& e) {
10457       {
10458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10459       };
10460     } catch (...) {
10461       {
10462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10463       };
10464     }
10465   }
10466   jresult = result;
10467   return jresult;
10468 }
10469
10470
10471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10472   float jresult ;
10473   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10474   float result;
10475
10476   arg1 = (Dali::Quaternion *)jarg1;
10477   {
10478     try {
10479       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10480     } catch (std::out_of_range& e) {
10481       {
10482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10483       };
10484     } catch (std::exception& e) {
10485       {
10486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10487       };
10488     } catch (...) {
10489       {
10490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10491       };
10492     }
10493   }
10494   jresult = result;
10495   return jresult;
10496 }
10497
10498
10499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10500   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10501
10502   arg1 = (Dali::Quaternion *)jarg1;
10503   {
10504     try {
10505       (arg1)->Normalize();
10506     } catch (std::out_of_range& e) {
10507       {
10508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10509       };
10510     } catch (std::exception& e) {
10511       {
10512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10513       };
10514     } catch (...) {
10515       {
10516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10517       };
10518     }
10519   }
10520 }
10521
10522
10523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10524   void * jresult ;
10525   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10526   Dali::Quaternion result;
10527
10528   arg1 = (Dali::Quaternion *)jarg1;
10529   {
10530     try {
10531       result = ((Dali::Quaternion const *)arg1)->Normalized();
10532     } catch (std::out_of_range& e) {
10533       {
10534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10535       };
10536     } catch (std::exception& e) {
10537       {
10538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10539       };
10540     } catch (...) {
10541       {
10542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10543       };
10544     }
10545   }
10546   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10547   return jresult;
10548 }
10549
10550
10551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10552   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10553
10554   arg1 = (Dali::Quaternion *)jarg1;
10555   {
10556     try {
10557       (arg1)->Conjugate();
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10565       };
10566     } catch (...) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10569       };
10570     }
10571   }
10572 }
10573
10574
10575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10577
10578   arg1 = (Dali::Quaternion *)jarg1;
10579   {
10580     try {
10581       (arg1)->Invert();
10582     } catch (std::out_of_range& e) {
10583       {
10584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10585       };
10586     } catch (std::exception& e) {
10587       {
10588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10589       };
10590     } catch (...) {
10591       {
10592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10593       };
10594     }
10595   }
10596 }
10597
10598
10599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10600   void * jresult ;
10601   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10602   Dali::Quaternion result;
10603
10604   arg1 = (Dali::Quaternion *)jarg1;
10605   {
10606     try {
10607       result = ((Dali::Quaternion const *)arg1)->Log();
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (...) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10619       };
10620     }
10621   }
10622   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10623   return jresult;
10624 }
10625
10626
10627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10628   void * jresult ;
10629   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10630   Dali::Quaternion result;
10631
10632   arg1 = (Dali::Quaternion *)jarg1;
10633   {
10634     try {
10635       result = ((Dali::Quaternion const *)arg1)->Exp();
10636     } catch (std::out_of_range& e) {
10637       {
10638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10639       };
10640     } catch (std::exception& e) {
10641       {
10642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10643       };
10644     } catch (...) {
10645       {
10646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10647       };
10648     }
10649   }
10650   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10651   return jresult;
10652 }
10653
10654
10655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10656   float jresult ;
10657   Dali::Quaternion *arg1 = 0 ;
10658   Dali::Quaternion *arg2 = 0 ;
10659   float result;
10660
10661   arg1 = (Dali::Quaternion *)jarg1;
10662   if (!arg1) {
10663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10664     return 0;
10665   }
10666   arg2 = (Dali::Quaternion *)jarg2;
10667   if (!arg2) {
10668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10669     return 0;
10670   }
10671   {
10672     try {
10673       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10674     } catch (std::out_of_range& e) {
10675       {
10676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10677       };
10678     } catch (std::exception& e) {
10679       {
10680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10681       };
10682     } catch (...) {
10683       {
10684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10685       };
10686     }
10687   }
10688   jresult = result;
10689   return jresult;
10690 }
10691
10692
10693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10694   void * jresult ;
10695   Dali::Quaternion *arg1 = 0 ;
10696   Dali::Quaternion *arg2 = 0 ;
10697   float arg3 ;
10698   Dali::Quaternion result;
10699
10700   arg1 = (Dali::Quaternion *)jarg1;
10701   if (!arg1) {
10702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10703     return 0;
10704   }
10705   arg2 = (Dali::Quaternion *)jarg2;
10706   if (!arg2) {
10707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10708     return 0;
10709   }
10710   arg3 = (float)jarg3;
10711   {
10712     try {
10713       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10714     } catch (std::out_of_range& e) {
10715       {
10716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10717       };
10718     } catch (std::exception& e) {
10719       {
10720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10721       };
10722     } catch (...) {
10723       {
10724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10725       };
10726     }
10727   }
10728   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10729   return jresult;
10730 }
10731
10732
10733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10734   void * jresult ;
10735   Dali::Quaternion *arg1 = 0 ;
10736   Dali::Quaternion *arg2 = 0 ;
10737   float arg3 ;
10738   Dali::Quaternion result;
10739
10740   arg1 = (Dali::Quaternion *)jarg1;
10741   if (!arg1) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10743     return 0;
10744   }
10745   arg2 = (Dali::Quaternion *)jarg2;
10746   if (!arg2) {
10747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10748     return 0;
10749   }
10750   arg3 = (float)jarg3;
10751   {
10752     try {
10753       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10754     } catch (std::out_of_range& e) {
10755       {
10756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10757       };
10758     } catch (std::exception& e) {
10759       {
10760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10761       };
10762     } catch (...) {
10763       {
10764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10765       };
10766     }
10767   }
10768   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10774   void * jresult ;
10775   Dali::Quaternion *arg1 = 0 ;
10776   Dali::Quaternion *arg2 = 0 ;
10777   float arg3 ;
10778   Dali::Quaternion result;
10779
10780   arg1 = (Dali::Quaternion *)jarg1;
10781   if (!arg1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10783     return 0;
10784   }
10785   arg2 = (Dali::Quaternion *)jarg2;
10786   if (!arg2) {
10787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10788     return 0;
10789   }
10790   arg3 = (float)jarg3;
10791   {
10792     try {
10793       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10794     } catch (std::out_of_range& e) {
10795       {
10796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (std::exception& e) {
10799       {
10800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10809   return jresult;
10810 }
10811
10812
10813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10814   void * jresult ;
10815   Dali::Quaternion *arg1 = 0 ;
10816   Dali::Quaternion *arg2 = 0 ;
10817   Dali::Quaternion *arg3 = 0 ;
10818   Dali::Quaternion *arg4 = 0 ;
10819   float arg5 ;
10820   Dali::Quaternion result;
10821
10822   arg1 = (Dali::Quaternion *)jarg1;
10823   if (!arg1) {
10824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10825     return 0;
10826   }
10827   arg2 = (Dali::Quaternion *)jarg2;
10828   if (!arg2) {
10829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10830     return 0;
10831   }
10832   arg3 = (Dali::Quaternion *)jarg3;
10833   if (!arg3) {
10834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10835     return 0;
10836   }
10837   arg4 = (Dali::Quaternion *)jarg4;
10838   if (!arg4) {
10839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10840     return 0;
10841   }
10842   arg5 = (float)jarg5;
10843   {
10844     try {
10845       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10846     } catch (std::out_of_range& e) {
10847       {
10848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10849       };
10850     } catch (std::exception& e) {
10851       {
10852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10853       };
10854     } catch (...) {
10855       {
10856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10857       };
10858     }
10859   }
10860   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10861   return jresult;
10862 }
10863
10864
10865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10866   float jresult ;
10867   Dali::Quaternion *arg1 = 0 ;
10868   Dali::Quaternion *arg2 = 0 ;
10869   float result;
10870
10871   arg1 = (Dali::Quaternion *)jarg1;
10872   if (!arg1) {
10873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10874     return 0;
10875   }
10876   arg2 = (Dali::Quaternion *)jarg2;
10877   if (!arg2) {
10878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10879     return 0;
10880   }
10881   {
10882     try {
10883       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10884     } catch (std::out_of_range& e) {
10885       {
10886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10887       };
10888     } catch (std::exception& e) {
10889       {
10890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10891       };
10892     } catch (...) {
10893       {
10894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10895       };
10896     }
10897   }
10898   jresult = result;
10899   return jresult;
10900 }
10901
10902
10903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10904   void * jresult ;
10905   Dali::Matrix *result = 0 ;
10906
10907   {
10908     try {
10909       result = (Dali::Matrix *)new Dali::Matrix();
10910     } catch (std::out_of_range& e) {
10911       {
10912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10913       };
10914     } catch (std::exception& e) {
10915       {
10916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10917       };
10918     } catch (...) {
10919       {
10920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10921       };
10922     }
10923   }
10924   jresult = (void *)result;
10925   return jresult;
10926 }
10927
10928
10929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10930   void * jresult ;
10931   bool arg1 ;
10932   Dali::Matrix *result = 0 ;
10933
10934   arg1 = jarg1 ? true : false;
10935   {
10936     try {
10937       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10938     } catch (std::out_of_range& e) {
10939       {
10940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10941       };
10942     } catch (std::exception& e) {
10943       {
10944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10945       };
10946     } catch (...) {
10947       {
10948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10949       };
10950     }
10951   }
10952   jresult = (void *)result;
10953   return jresult;
10954 }
10955
10956
10957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10958   void * jresult ;
10959   float *arg1 = (float *) 0 ;
10960   Dali::Matrix *result = 0 ;
10961
10962   arg1 = jarg1;
10963   {
10964     try {
10965       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10966     } catch (std::out_of_range& e) {
10967       {
10968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10969       };
10970     } catch (std::exception& e) {
10971       {
10972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10973       };
10974     } catch (...) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10977       };
10978     }
10979   }
10980   jresult = (void *)result;
10981
10982
10983   return jresult;
10984 }
10985
10986
10987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10988   void * jresult ;
10989   Dali::Quaternion *arg1 = 0 ;
10990   Dali::Matrix *result = 0 ;
10991
10992   arg1 = (Dali::Quaternion *)jarg1;
10993   if (!arg1) {
10994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10995     return 0;
10996   }
10997   {
10998     try {
10999       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11000     } catch (std::out_of_range& e) {
11001       {
11002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11003       };
11004     } catch (std::exception& e) {
11005       {
11006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11007       };
11008     } catch (...) {
11009       {
11010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11011       };
11012     }
11013   }
11014   jresult = (void *)result;
11015   return jresult;
11016 }
11017
11018
11019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11020   void * jresult ;
11021   Dali::Matrix *arg1 = 0 ;
11022   Dali::Matrix *result = 0 ;
11023
11024   arg1 = (Dali::Matrix *)jarg1;
11025   if (!arg1) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11027     return 0;
11028   }
11029   {
11030     try {
11031       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11032     } catch (std::out_of_range& e) {
11033       {
11034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11035       };
11036     } catch (std::exception& e) {
11037       {
11038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11039       };
11040     } catch (...) {
11041       {
11042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11043       };
11044     }
11045   }
11046   jresult = (void *)result;
11047   return jresult;
11048 }
11049
11050
11051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11052   void * jresult ;
11053   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11054   Dali::Matrix *arg2 = 0 ;
11055   Dali::Matrix *result = 0 ;
11056
11057   arg1 = (Dali::Matrix *)jarg1;
11058   arg2 = (Dali::Matrix *)jarg2;
11059   if (!arg2) {
11060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11061     return 0;
11062   }
11063   {
11064     try {
11065       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11066     } catch (std::out_of_range& e) {
11067       {
11068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11069       };
11070     } catch (std::exception& e) {
11071       {
11072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11077       };
11078     }
11079   }
11080   jresult = (void *)result;
11081   return jresult;
11082 }
11083
11084
11085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11086   void * jresult ;
11087   Dali::Matrix *result = 0 ;
11088
11089   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11090   jresult = (void *)result;
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11096   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11097
11098   arg1 = (Dali::Matrix *)jarg1;
11099   {
11100     try {
11101       (arg1)->SetIdentity();
11102     } catch (std::out_of_range& e) {
11103       {
11104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11105       };
11106     } catch (std::exception& e) {
11107       {
11108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11109       };
11110     } catch (...) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11113       };
11114     }
11115   }
11116 }
11117
11118
11119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11120   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11121   Dali::Vector3 *arg2 = 0 ;
11122
11123   arg1 = (Dali::Matrix *)jarg1;
11124   arg2 = (Dali::Vector3 *)jarg2;
11125   if (!arg2) {
11126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11127     return ;
11128   }
11129   {
11130     try {
11131       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11132     } catch (std::out_of_range& e) {
11133       {
11134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11135       };
11136     } catch (std::exception& e) {
11137       {
11138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11139       };
11140     } catch (...) {
11141       {
11142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11143       };
11144     }
11145   }
11146 }
11147
11148
11149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11150   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11151   Dali::Matrix *arg2 = 0 ;
11152
11153   arg1 = (Dali::Matrix *)jarg1;
11154   arg2 = (Dali::Matrix *)jarg2;
11155   if (!arg2) {
11156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11157     return ;
11158   }
11159   {
11160     try {
11161       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11162     } catch (std::out_of_range& e) {
11163       {
11164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11165       };
11166     } catch (std::exception& e) {
11167       {
11168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11169       };
11170     } catch (...) {
11171       {
11172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11173       };
11174     }
11175   }
11176 }
11177
11178
11179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11180   unsigned int jresult ;
11181   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11182   bool result;
11183
11184   arg1 = (Dali::Matrix *)jarg1;
11185   {
11186     try {
11187       result = (bool)(arg1)->Invert();
11188     } catch (std::out_of_range& e) {
11189       {
11190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11191       };
11192     } catch (std::exception& e) {
11193       {
11194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11195       };
11196     } catch (...) {
11197       {
11198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11199       };
11200     }
11201   }
11202   jresult = result;
11203   return jresult;
11204 }
11205
11206
11207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11208   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11209
11210   arg1 = (Dali::Matrix *)jarg1;
11211   {
11212     try {
11213       (arg1)->Transpose();
11214     } catch (std::out_of_range& e) {
11215       {
11216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11217       };
11218     } catch (std::exception& e) {
11219       {
11220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11221       };
11222     } catch (...) {
11223       {
11224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11225       };
11226     }
11227   }
11228 }
11229
11230
11231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11232   void * jresult ;
11233   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11234   Dali::Vector3 result;
11235
11236   arg1 = (Dali::Matrix *)jarg1;
11237   {
11238     try {
11239       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11240     } catch (std::out_of_range& e) {
11241       {
11242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11243       };
11244     } catch (std::exception& e) {
11245       {
11246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11247       };
11248     } catch (...) {
11249       {
11250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11251       };
11252     }
11253   }
11254   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11255   return jresult;
11256 }
11257
11258
11259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11260   void * jresult ;
11261   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11262   Dali::Vector3 result;
11263
11264   arg1 = (Dali::Matrix *)jarg1;
11265   {
11266     try {
11267       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11268     } catch (std::out_of_range& e) {
11269       {
11270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11271       };
11272     } catch (std::exception& e) {
11273       {
11274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11275       };
11276     } catch (...) {
11277       {
11278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11279       };
11280     }
11281   }
11282   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11283   return jresult;
11284 }
11285
11286
11287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11288   void * jresult ;
11289   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11290   Dali::Vector3 result;
11291
11292   arg1 = (Dali::Matrix *)jarg1;
11293   {
11294     try {
11295       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11296     } catch (std::out_of_range& e) {
11297       {
11298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11299       };
11300     } catch (std::exception& e) {
11301       {
11302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11303       };
11304     } catch (...) {
11305       {
11306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11307       };
11308     }
11309   }
11310   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11311   return jresult;
11312 }
11313
11314
11315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11316   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11317   Dali::Vector3 *arg2 = 0 ;
11318
11319   arg1 = (Dali::Matrix *)jarg1;
11320   arg2 = (Dali::Vector3 *)jarg2;
11321   if (!arg2) {
11322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11323     return ;
11324   }
11325   {
11326     try {
11327       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11328     } catch (std::out_of_range& e) {
11329       {
11330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11331       };
11332     } catch (std::exception& e) {
11333       {
11334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11335       };
11336     } catch (...) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11339       };
11340     }
11341   }
11342 }
11343
11344
11345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11346   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11347   Dali::Vector3 *arg2 = 0 ;
11348
11349   arg1 = (Dali::Matrix *)jarg1;
11350   arg2 = (Dali::Vector3 *)jarg2;
11351   if (!arg2) {
11352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11353     return ;
11354   }
11355   {
11356     try {
11357       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11358     } catch (std::out_of_range& e) {
11359       {
11360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11361       };
11362     } catch (std::exception& e) {
11363       {
11364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11365       };
11366     } catch (...) {
11367       {
11368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11369       };
11370     }
11371   }
11372 }
11373
11374
11375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11376   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11377   Dali::Vector3 *arg2 = 0 ;
11378
11379   arg1 = (Dali::Matrix *)jarg1;
11380   arg2 = (Dali::Vector3 *)jarg2;
11381   if (!arg2) {
11382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11383     return ;
11384   }
11385   {
11386     try {
11387       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11388     } catch (std::out_of_range& e) {
11389       {
11390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11391       };
11392     } catch (std::exception& e) {
11393       {
11394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11395       };
11396     } catch (...) {
11397       {
11398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11399       };
11400     }
11401   }
11402 }
11403
11404
11405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11406   void * jresult ;
11407   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11408   Dali::Vector4 *result = 0 ;
11409
11410   arg1 = (Dali::Matrix *)jarg1;
11411   {
11412     try {
11413       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11414     } catch (std::out_of_range& e) {
11415       {
11416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11417       };
11418     } catch (std::exception& e) {
11419       {
11420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11421       };
11422     } catch (...) {
11423       {
11424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11425       };
11426     }
11427   }
11428   jresult = (void *)result;
11429   return jresult;
11430 }
11431
11432
11433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11434   void * jresult ;
11435   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11436   Dali::Vector3 *result = 0 ;
11437
11438   arg1 = (Dali::Matrix *)jarg1;
11439   {
11440     try {
11441       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11442     } catch (std::out_of_range& e) {
11443       {
11444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11445       };
11446     } catch (std::exception& e) {
11447       {
11448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11449       };
11450     } catch (...) {
11451       {
11452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11453       };
11454     }
11455   }
11456   jresult = (void *)result;
11457   return jresult;
11458 }
11459
11460
11461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11462   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11463   Dali::Vector4 *arg2 = 0 ;
11464
11465   arg1 = (Dali::Matrix *)jarg1;
11466   arg2 = (Dali::Vector4 *)jarg2;
11467   if (!arg2) {
11468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11469     return ;
11470   }
11471   {
11472     try {
11473       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11474     } catch (std::out_of_range& e) {
11475       {
11476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11477       };
11478     } catch (std::exception& e) {
11479       {
11480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11481       };
11482     } catch (...) {
11483       {
11484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11485       };
11486     }
11487   }
11488 }
11489
11490
11491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11492   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11493   Dali::Vector3 *arg2 = 0 ;
11494
11495   arg1 = (Dali::Matrix *)jarg1;
11496   arg2 = (Dali::Vector3 *)jarg2;
11497   if (!arg2) {
11498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11499     return ;
11500   }
11501   {
11502     try {
11503       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11504     } catch (std::out_of_range& e) {
11505       {
11506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11507       };
11508     } catch (std::exception& e) {
11509       {
11510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11511       };
11512     } catch (...) {
11513       {
11514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11515       };
11516     }
11517   }
11518 }
11519
11520
11521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11522   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11523
11524   arg1 = (Dali::Matrix *)jarg1;
11525   {
11526     try {
11527       (arg1)->OrthoNormalize();
11528     } catch (std::out_of_range& e) {
11529       {
11530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11531       };
11532     } catch (std::exception& e) {
11533       {
11534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11535       };
11536     } catch (...) {
11537       {
11538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11539       };
11540     }
11541   }
11542 }
11543
11544
11545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11546   void * jresult ;
11547   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11548   float *result = 0 ;
11549
11550   arg1 = (Dali::Matrix *)jarg1;
11551   {
11552     try {
11553       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
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 (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568   jresult = (void *)result;
11569   return jresult;
11570 }
11571
11572
11573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11574   Dali::Matrix *arg1 = 0 ;
11575   Dali::Matrix *arg2 = 0 ;
11576   Dali::Matrix *arg3 = 0 ;
11577
11578   arg1 = (Dali::Matrix *)jarg1;
11579   if (!arg1) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11581     return ;
11582   }
11583   arg2 = (Dali::Matrix *)jarg2;
11584   if (!arg2) {
11585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11586     return ;
11587   }
11588   arg3 = (Dali::Matrix *)jarg3;
11589   if (!arg3) {
11590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11591     return ;
11592   }
11593   {
11594     try {
11595       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11596     } catch (std::out_of_range& e) {
11597       {
11598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11599       };
11600     } catch (std::exception& e) {
11601       {
11602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11603       };
11604     } catch (...) {
11605       {
11606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11607       };
11608     }
11609   }
11610 }
11611
11612
11613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11614   Dali::Matrix *arg1 = 0 ;
11615   Dali::Matrix *arg2 = 0 ;
11616   Dali::Quaternion *arg3 = 0 ;
11617
11618   arg1 = (Dali::Matrix *)jarg1;
11619   if (!arg1) {
11620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11621     return ;
11622   }
11623   arg2 = (Dali::Matrix *)jarg2;
11624   if (!arg2) {
11625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11626     return ;
11627   }
11628   arg3 = (Dali::Quaternion *)jarg3;
11629   if (!arg3) {
11630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11631     return ;
11632   }
11633   {
11634     try {
11635       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11636     } catch (std::out_of_range& e) {
11637       {
11638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11639       };
11640     } catch (std::exception& e) {
11641       {
11642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11643       };
11644     } catch (...) {
11645       {
11646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11647       };
11648     }
11649   }
11650 }
11651
11652
11653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11654   void * jresult ;
11655   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11656   Dali::Vector4 *arg2 = 0 ;
11657   Dali::Vector4 result;
11658
11659   arg1 = (Dali::Matrix *)jarg1;
11660   arg2 = (Dali::Vector4 *)jarg2;
11661   if (!arg2) {
11662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11663     return 0;
11664   }
11665   {
11666     try {
11667       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11668     } catch (std::out_of_range& e) {
11669       {
11670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11671       };
11672     } catch (std::exception& e) {
11673       {
11674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11675       };
11676     } catch (...) {
11677       {
11678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11679       };
11680     }
11681   }
11682   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11683   return jresult;
11684 }
11685
11686
11687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11688   unsigned int jresult ;
11689   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11690   Dali::Matrix *arg2 = 0 ;
11691   bool result;
11692
11693   arg1 = (Dali::Matrix *)jarg1;
11694   arg2 = (Dali::Matrix *)jarg2;
11695   if (!arg2) {
11696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11697     return 0;
11698   }
11699   {
11700     try {
11701       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11702     } catch (std::out_of_range& e) {
11703       {
11704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11705       };
11706     } catch (std::exception& e) {
11707       {
11708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11709       };
11710     } catch (...) {
11711       {
11712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11713       };
11714     }
11715   }
11716   jresult = result;
11717   return jresult;
11718 }
11719
11720
11721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11722   unsigned int jresult ;
11723   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11724   Dali::Matrix *arg2 = 0 ;
11725   bool result;
11726
11727   arg1 = (Dali::Matrix *)jarg1;
11728   arg2 = (Dali::Matrix *)jarg2;
11729   if (!arg2) {
11730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11731     return 0;
11732   }
11733   {
11734     try {
11735       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11736     } catch (std::out_of_range& e) {
11737       {
11738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11739       };
11740     } catch (std::exception& e) {
11741       {
11742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11743       };
11744     } catch (...) {
11745       {
11746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11747       };
11748     }
11749   }
11750   jresult = result;
11751   return jresult;
11752 }
11753
11754
11755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11756   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11757   Dali::Vector3 *arg2 = 0 ;
11758   Dali::Quaternion *arg3 = 0 ;
11759   Dali::Vector3 *arg4 = 0 ;
11760
11761   arg1 = (Dali::Matrix *)jarg1;
11762   arg2 = (Dali::Vector3 *)jarg2;
11763   if (!arg2) {
11764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11765     return ;
11766   }
11767   arg3 = (Dali::Quaternion *)jarg3;
11768   if (!arg3) {
11769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11770     return ;
11771   }
11772   arg4 = (Dali::Vector3 *)jarg4;
11773   if (!arg4) {
11774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11775     return ;
11776   }
11777   {
11778     try {
11779       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11780     } catch (std::out_of_range& e) {
11781       {
11782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11783       };
11784     } catch (std::exception& e) {
11785       {
11786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11787       };
11788     } catch (...) {
11789       {
11790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11791       };
11792     }
11793   }
11794 }
11795
11796
11797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11798   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11799   Dali::Vector3 *arg2 = 0 ;
11800   Dali::Quaternion *arg3 = 0 ;
11801   Dali::Vector3 *arg4 = 0 ;
11802
11803   arg1 = (Dali::Matrix *)jarg1;
11804   arg2 = (Dali::Vector3 *)jarg2;
11805   if (!arg2) {
11806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11807     return ;
11808   }
11809   arg3 = (Dali::Quaternion *)jarg3;
11810   if (!arg3) {
11811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11812     return ;
11813   }
11814   arg4 = (Dali::Vector3 *)jarg4;
11815   if (!arg4) {
11816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11817     return ;
11818   }
11819   {
11820     try {
11821       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11822     } catch (std::out_of_range& e) {
11823       {
11824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11825       };
11826     } catch (std::exception& e) {
11827       {
11828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11829       };
11830     } catch (...) {
11831       {
11832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11833       };
11834     }
11835   }
11836 }
11837
11838
11839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11840   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11841   Dali::Vector3 *arg2 = 0 ;
11842   Dali::Vector3 *arg3 = 0 ;
11843   Dali::Vector3 *arg4 = 0 ;
11844   Dali::Vector3 *arg5 = 0 ;
11845
11846   arg1 = (Dali::Matrix *)jarg1;
11847   arg2 = (Dali::Vector3 *)jarg2;
11848   if (!arg2) {
11849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11850     return ;
11851   }
11852   arg3 = (Dali::Vector3 *)jarg3;
11853   if (!arg3) {
11854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11855     return ;
11856   }
11857   arg4 = (Dali::Vector3 *)jarg4;
11858   if (!arg4) {
11859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11860     return ;
11861   }
11862   arg5 = (Dali::Vector3 *)jarg5;
11863   if (!arg5) {
11864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11865     return ;
11866   }
11867   {
11868     try {
11869       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11870     } catch (std::out_of_range& e) {
11871       {
11872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11873       };
11874     } catch (std::exception& e) {
11875       {
11876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11877       };
11878     } catch (...) {
11879       {
11880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11881       };
11882     }
11883   }
11884 }
11885
11886
11887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11888   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11889   Dali::Vector3 *arg2 = 0 ;
11890   Dali::Quaternion *arg3 = 0 ;
11891   Dali::Vector3 *arg4 = 0 ;
11892
11893   arg1 = (Dali::Matrix *)jarg1;
11894   arg2 = (Dali::Vector3 *)jarg2;
11895   if (!arg2) {
11896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11897     return ;
11898   }
11899   arg3 = (Dali::Quaternion *)jarg3;
11900   if (!arg3) {
11901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11902     return ;
11903   }
11904   arg4 = (Dali::Vector3 *)jarg4;
11905   if (!arg4) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11907     return ;
11908   }
11909   {
11910     try {
11911       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11912     } catch (std::out_of_range& e) {
11913       {
11914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11915       };
11916     } catch (std::exception& e) {
11917       {
11918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11919       };
11920     } catch (...) {
11921       {
11922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11923       };
11924     }
11925   }
11926 }
11927
11928
11929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11930   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11931
11932   arg1 = (Dali::Matrix *)jarg1;
11933   {
11934     try {
11935       delete arg1;
11936     } catch (std::out_of_range& e) {
11937       {
11938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11939       };
11940     } catch (std::exception& e) {
11941       {
11942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11943       };
11944     } catch (...) {
11945       {
11946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11947       };
11948     }
11949   }
11950 }
11951
11952
11953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11954   void * jresult ;
11955   Dali::Matrix3 *result = 0 ;
11956
11957   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11958   jresult = (void *)result;
11959   return jresult;
11960 }
11961
11962
11963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11964   void * jresult ;
11965   Dali::Matrix3 *result = 0 ;
11966
11967   {
11968     try {
11969       result = (Dali::Matrix3 *)new Dali::Matrix3();
11970     } catch (std::out_of_range& e) {
11971       {
11972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (std::exception& e) {
11975       {
11976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984   jresult = (void *)result;
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11990   void * jresult ;
11991   Dali::Matrix3 *arg1 = 0 ;
11992   Dali::Matrix3 *result = 0 ;
11993
11994   arg1 = (Dali::Matrix3 *)jarg1;
11995   if (!arg1) {
11996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11997     return 0;
11998   }
11999   {
12000     try {
12001       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12002     } catch (std::out_of_range& e) {
12003       {
12004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12005       };
12006     } catch (std::exception& e) {
12007       {
12008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12009       };
12010     } catch (...) {
12011       {
12012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12013       };
12014     }
12015   }
12016   jresult = (void *)result;
12017   return jresult;
12018 }
12019
12020
12021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12022   void * jresult ;
12023   Dali::Matrix *arg1 = 0 ;
12024   Dali::Matrix3 *result = 0 ;
12025
12026   arg1 = (Dali::Matrix *)jarg1;
12027   if (!arg1) {
12028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12029     return 0;
12030   }
12031   {
12032     try {
12033       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12034     } catch (std::out_of_range& e) {
12035       {
12036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12037       };
12038     } catch (std::exception& e) {
12039       {
12040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12041       };
12042     } catch (...) {
12043       {
12044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12045       };
12046     }
12047   }
12048   jresult = (void *)result;
12049   return jresult;
12050 }
12051
12052
12053 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) {
12054   void * jresult ;
12055   float arg1 ;
12056   float arg2 ;
12057   float arg3 ;
12058   float arg4 ;
12059   float arg5 ;
12060   float arg6 ;
12061   float arg7 ;
12062   float arg8 ;
12063   float arg9 ;
12064   Dali::Matrix3 *result = 0 ;
12065
12066   arg1 = (float)jarg1;
12067   arg2 = (float)jarg2;
12068   arg3 = (float)jarg3;
12069   arg4 = (float)jarg4;
12070   arg5 = (float)jarg5;
12071   arg6 = (float)jarg6;
12072   arg7 = (float)jarg7;
12073   arg8 = (float)jarg8;
12074   arg9 = (float)jarg9;
12075   {
12076     try {
12077       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12078     } catch (std::out_of_range& e) {
12079       {
12080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12081       };
12082     } catch (std::exception& e) {
12083       {
12084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12085       };
12086     } catch (...) {
12087       {
12088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12089       };
12090     }
12091   }
12092   jresult = (void *)result;
12093   return jresult;
12094 }
12095
12096
12097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12098   void * jresult ;
12099   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12100   Dali::Matrix3 *arg2 = 0 ;
12101   Dali::Matrix3 *result = 0 ;
12102
12103   arg1 = (Dali::Matrix3 *)jarg1;
12104   arg2 = (Dali::Matrix3 *)jarg2;
12105   if (!arg2) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12107     return 0;
12108   }
12109   {
12110     try {
12111       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (...) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12123       };
12124     }
12125   }
12126   jresult = (void *)result;
12127   return jresult;
12128 }
12129
12130
12131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12132   void * jresult ;
12133   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12134   Dali::Matrix *arg2 = 0 ;
12135   Dali::Matrix3 *result = 0 ;
12136
12137   arg1 = (Dali::Matrix3 *)jarg1;
12138   arg2 = (Dali::Matrix *)jarg2;
12139   if (!arg2) {
12140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12141     return 0;
12142   }
12143   {
12144     try {
12145       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12146     } catch (std::out_of_range& e) {
12147       {
12148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12149       };
12150     } catch (std::exception& e) {
12151       {
12152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12153       };
12154     } catch (...) {
12155       {
12156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12157       };
12158     }
12159   }
12160   jresult = (void *)result;
12161   return jresult;
12162 }
12163
12164
12165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12166   unsigned int jresult ;
12167   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12168   Dali::Matrix3 *arg2 = 0 ;
12169   bool result;
12170
12171   arg1 = (Dali::Matrix3 *)jarg1;
12172   arg2 = (Dali::Matrix3 *)jarg2;
12173   if (!arg2) {
12174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12175     return 0;
12176   }
12177   {
12178     try {
12179       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12180     } catch (std::out_of_range& e) {
12181       {
12182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12183       };
12184     } catch (std::exception& e) {
12185       {
12186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12187       };
12188     } catch (...) {
12189       {
12190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12191       };
12192     }
12193   }
12194   jresult = result;
12195   return jresult;
12196 }
12197
12198
12199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12200   unsigned int jresult ;
12201   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12202   Dali::Matrix3 *arg2 = 0 ;
12203   bool result;
12204
12205   arg1 = (Dali::Matrix3 *)jarg1;
12206   arg2 = (Dali::Matrix3 *)jarg2;
12207   if (!arg2) {
12208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12209     return 0;
12210   }
12211   {
12212     try {
12213       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12214     } catch (std::out_of_range& e) {
12215       {
12216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12217       };
12218     } catch (std::exception& e) {
12219       {
12220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (...) {
12223       {
12224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12225       };
12226     }
12227   }
12228   jresult = result;
12229   return jresult;
12230 }
12231
12232
12233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12234   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12235
12236   arg1 = (Dali::Matrix3 *)jarg1;
12237   {
12238     try {
12239       delete arg1;
12240     } catch (std::out_of_range& e) {
12241       {
12242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12243       };
12244     } catch (std::exception& e) {
12245       {
12246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12247       };
12248     } catch (...) {
12249       {
12250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12251       };
12252     }
12253   }
12254 }
12255
12256
12257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12258   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12259
12260   arg1 = (Dali::Matrix3 *)jarg1;
12261   {
12262     try {
12263       (arg1)->SetIdentity();
12264     } catch (std::out_of_range& e) {
12265       {
12266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12267       };
12268     } catch (std::exception& e) {
12269       {
12270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12271       };
12272     } catch (...) {
12273       {
12274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12275       };
12276     }
12277   }
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12282   void * jresult ;
12283   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12284   float *result = 0 ;
12285
12286   arg1 = (Dali::Matrix3 *)jarg1;
12287   {
12288     try {
12289       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12290     } catch (std::out_of_range& e) {
12291       {
12292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12293       };
12294     } catch (std::exception& e) {
12295       {
12296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (...) {
12299       {
12300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12301       };
12302     }
12303   }
12304   jresult = (void *)result;
12305   return jresult;
12306 }
12307
12308
12309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12310   unsigned int jresult ;
12311   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12312   bool result;
12313
12314   arg1 = (Dali::Matrix3 *)jarg1;
12315   {
12316     try {
12317       result = (bool)(arg1)->Invert();
12318     } catch (std::out_of_range& e) {
12319       {
12320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12321       };
12322     } catch (std::exception& e) {
12323       {
12324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12325       };
12326     } catch (...) {
12327       {
12328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12329       };
12330     }
12331   }
12332   jresult = result;
12333   return jresult;
12334 }
12335
12336
12337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12338   unsigned int jresult ;
12339   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12340   bool result;
12341
12342   arg1 = (Dali::Matrix3 *)jarg1;
12343   {
12344     try {
12345       result = (bool)(arg1)->Transpose();
12346     } catch (std::out_of_range& e) {
12347       {
12348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12349       };
12350     } catch (std::exception& e) {
12351       {
12352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12353       };
12354     } catch (...) {
12355       {
12356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12357       };
12358     }
12359   }
12360   jresult = result;
12361   return jresult;
12362 }
12363
12364
12365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12366   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12367   float arg2 ;
12368
12369   arg1 = (Dali::Matrix3 *)jarg1;
12370   arg2 = (float)jarg2;
12371   {
12372     try {
12373       (arg1)->Scale(arg2);
12374     } catch (std::out_of_range& e) {
12375       {
12376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12377       };
12378     } catch (std::exception& e) {
12379       {
12380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12385       };
12386     }
12387   }
12388 }
12389
12390
12391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12392   float jresult ;
12393   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12394   float result;
12395
12396   arg1 = (Dali::Matrix3 *)jarg1;
12397   {
12398     try {
12399       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12400     } catch (std::out_of_range& e) {
12401       {
12402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12403       };
12404     } catch (std::exception& e) {
12405       {
12406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12407       };
12408     } catch (...) {
12409       {
12410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12411       };
12412     }
12413   }
12414   jresult = result;
12415   return jresult;
12416 }
12417
12418
12419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12420   unsigned int jresult ;
12421   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12422   bool result;
12423
12424   arg1 = (Dali::Matrix3 *)jarg1;
12425   {
12426     try {
12427       result = (bool)(arg1)->ScaledInverseTranspose();
12428     } catch (std::out_of_range& e) {
12429       {
12430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12431       };
12432     } catch (std::exception& e) {
12433       {
12434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12435       };
12436     } catch (...) {
12437       {
12438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12439       };
12440     }
12441   }
12442   jresult = result;
12443   return jresult;
12444 }
12445
12446
12447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12448   Dali::Matrix3 *arg1 = 0 ;
12449   Dali::Matrix3 *arg2 = 0 ;
12450   Dali::Matrix3 *arg3 = 0 ;
12451
12452   arg1 = (Dali::Matrix3 *)jarg1;
12453   if (!arg1) {
12454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12455     return ;
12456   }
12457   arg2 = (Dali::Matrix3 *)jarg2;
12458   if (!arg2) {
12459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12460     return ;
12461   }
12462   arg3 = (Dali::Matrix3 *)jarg3;
12463   if (!arg3) {
12464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12465     return ;
12466   }
12467   {
12468     try {
12469       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12470     } catch (std::out_of_range& e) {
12471       {
12472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12473       };
12474     } catch (std::exception& e) {
12475       {
12476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12477       };
12478     } catch (...) {
12479       {
12480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12481       };
12482     }
12483   }
12484 }
12485
12486
12487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12488   float jresult ;
12489   float arg1 ;
12490   float arg2 ;
12491   float result;
12492
12493   arg1 = (float)jarg1;
12494   arg2 = (float)jarg2;
12495   {
12496     try {
12497       result = (float)Dali::Random::Range(arg1,arg2);
12498     } catch (std::out_of_range& e) {
12499       {
12500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12501       };
12502     } catch (std::exception& e) {
12503       {
12504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12505       };
12506     } catch (...) {
12507       {
12508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12509       };
12510     }
12511   }
12512   jresult = result;
12513   return jresult;
12514 }
12515
12516
12517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12518   void * jresult ;
12519   Dali::Vector4 result;
12520
12521   {
12522     try {
12523       result = Dali::Random::Axis();
12524     } catch (std::out_of_range& e) {
12525       {
12526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12527       };
12528     } catch (std::exception& e) {
12529       {
12530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12531       };
12532     } catch (...) {
12533       {
12534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12535       };
12536     }
12537   }
12538   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12539   return jresult;
12540 }
12541
12542
12543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12544   void * jresult ;
12545   Dali::AngleAxis *result = 0 ;
12546
12547   {
12548     try {
12549       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12550     } catch (std::out_of_range& e) {
12551       {
12552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12553       };
12554     } catch (std::exception& e) {
12555       {
12556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12557       };
12558     } catch (...) {
12559       {
12560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12561       };
12562     }
12563   }
12564   jresult = (void *)result;
12565   return jresult;
12566 }
12567
12568
12569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12570   void * jresult ;
12571   Dali::Radian arg1 ;
12572   Dali::Vector3 *arg2 = 0 ;
12573   Dali::Radian *argp1 ;
12574   Dali::AngleAxis *result = 0 ;
12575
12576   argp1 = (Dali::Radian *)jarg1;
12577   if (!argp1) {
12578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12579     return 0;
12580   }
12581   arg1 = *argp1;
12582   arg2 = (Dali::Vector3 *)jarg2;
12583   if (!arg2) {
12584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12585     return 0;
12586   }
12587   {
12588     try {
12589       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12590     } catch (std::out_of_range& e) {
12591       {
12592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12593       };
12594     } catch (std::exception& e) {
12595       {
12596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12597       };
12598     } catch (...) {
12599       {
12600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12601       };
12602     }
12603   }
12604   jresult = (void *)result;
12605   return jresult;
12606 }
12607
12608
12609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12610   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12611   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12612
12613   arg1 = (Dali::AngleAxis *)jarg1;
12614   arg2 = (Dali::Radian *)jarg2;
12615   if (arg1) (arg1)->angle = *arg2;
12616 }
12617
12618
12619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12620   void * jresult ;
12621   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12622   Dali::Radian *result = 0 ;
12623
12624   arg1 = (Dali::AngleAxis *)jarg1;
12625   result = (Dali::Radian *)& ((arg1)->angle);
12626   jresult = (void *)result;
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12632   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12633   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12634
12635   arg1 = (Dali::AngleAxis *)jarg1;
12636   arg2 = (Dali::Vector3 *)jarg2;
12637   if (arg1) (arg1)->axis = *arg2;
12638 }
12639
12640
12641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12642   void * jresult ;
12643   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12644   Dali::Vector3 *result = 0 ;
12645
12646   arg1 = (Dali::AngleAxis *)jarg1;
12647   result = (Dali::Vector3 *)& ((arg1)->axis);
12648   jresult = (void *)result;
12649   return jresult;
12650 }
12651
12652
12653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12654   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12655
12656   arg1 = (Dali::AngleAxis *)jarg1;
12657   {
12658     try {
12659       delete arg1;
12660     } catch (std::out_of_range& e) {
12661       {
12662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12663       };
12664     } catch (std::exception& e) {
12665       {
12666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12667       };
12668     } catch (...) {
12669       {
12670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12671       };
12672     }
12673   }
12674 }
12675
12676
12677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12678   unsigned int jresult ;
12679   Dali::AngleAxis *arg1 = 0 ;
12680   Dali::AngleAxis *arg2 = 0 ;
12681   bool result;
12682
12683   arg1 = (Dali::AngleAxis *)jarg1;
12684   if (!arg1) {
12685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12686     return 0;
12687   }
12688   arg2 = (Dali::AngleAxis *)jarg2;
12689   if (!arg2) {
12690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12691     return 0;
12692   }
12693   {
12694     try {
12695       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12696     } catch (std::out_of_range& e) {
12697       {
12698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12699       };
12700     } catch (std::exception& e) {
12701       {
12702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12703       };
12704     } catch (...) {
12705       {
12706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12707       };
12708     }
12709   }
12710   jresult = result;
12711   return jresult;
12712 }
12713
12714
12715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12716   unsigned int jresult ;
12717   unsigned int arg1 ;
12718   unsigned int result;
12719
12720   arg1 = (unsigned int)jarg1;
12721   {
12722     try {
12723       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12724     } catch (std::out_of_range& e) {
12725       {
12726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12727       };
12728     } catch (std::exception& e) {
12729       {
12730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12731       };
12732     } catch (...) {
12733       {
12734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12735       };
12736     }
12737   }
12738   jresult = result;
12739   return jresult;
12740 }
12741
12742
12743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12744   unsigned int jresult ;
12745   unsigned int arg1 ;
12746   bool result;
12747
12748   arg1 = (unsigned int)jarg1;
12749   {
12750     try {
12751       result = (bool)Dali::IsPowerOfTwo(arg1);
12752     } catch (std::out_of_range& e) {
12753       {
12754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12755       };
12756     } catch (std::exception& e) {
12757       {
12758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12759       };
12760     } catch (...) {
12761       {
12762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12763       };
12764     }
12765   }
12766   jresult = result;
12767   return jresult;
12768 }
12769
12770
12771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12772   float jresult ;
12773   float arg1 ;
12774   float arg2 ;
12775   float result;
12776
12777   arg1 = (float)jarg1;
12778   arg2 = (float)jarg2;
12779   {
12780     try {
12781       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12782     } catch (std::out_of_range& e) {
12783       {
12784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (std::exception& e) {
12787       {
12788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796   jresult = result;
12797   return jresult;
12798 }
12799
12800
12801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12802   unsigned int jresult ;
12803   float arg1 ;
12804   bool result;
12805
12806   arg1 = (float)jarg1;
12807   {
12808     try {
12809       result = (bool)Dali::EqualsZero(arg1);
12810     } catch (std::out_of_range& e) {
12811       {
12812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12813       };
12814     } catch (std::exception& e) {
12815       {
12816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12817       };
12818     } catch (...) {
12819       {
12820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12821       };
12822     }
12823   }
12824   jresult = result;
12825   return jresult;
12826 }
12827
12828
12829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12830   unsigned int jresult ;
12831   float arg1 ;
12832   float arg2 ;
12833   bool result;
12834
12835   arg1 = (float)jarg1;
12836   arg2 = (float)jarg2;
12837   {
12838     try {
12839       result = (bool)Dali::Equals(arg1,arg2);
12840     } catch (std::out_of_range& e) {
12841       {
12842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12843       };
12844     } catch (std::exception& e) {
12845       {
12846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12847       };
12848     } catch (...) {
12849       {
12850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12851       };
12852     }
12853   }
12854   jresult = result;
12855   return jresult;
12856 }
12857
12858
12859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12860   unsigned int jresult ;
12861   float arg1 ;
12862   float arg2 ;
12863   float arg3 ;
12864   bool result;
12865
12866   arg1 = (float)jarg1;
12867   arg2 = (float)jarg2;
12868   arg3 = (float)jarg3;
12869   {
12870     try {
12871       result = (bool)Dali::Equals(arg1,arg2,arg3);
12872     } catch (std::out_of_range& e) {
12873       {
12874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12875       };
12876     } catch (std::exception& e) {
12877       {
12878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12879       };
12880     } catch (...) {
12881       {
12882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12883       };
12884     }
12885   }
12886   jresult = result;
12887   return jresult;
12888 }
12889
12890
12891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12892   float jresult ;
12893   float arg1 ;
12894   int arg2 ;
12895   float result;
12896
12897   arg1 = (float)jarg1;
12898   arg2 = (int)jarg2;
12899   {
12900     try {
12901       result = (float)Dali::Round(arg1,arg2);
12902     } catch (std::out_of_range& e) {
12903       {
12904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12905       };
12906     } catch (std::exception& e) {
12907       {
12908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12909       };
12910     } catch (...) {
12911       {
12912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12913       };
12914     }
12915   }
12916   jresult = result;
12917   return jresult;
12918 }
12919
12920
12921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12922   float jresult ;
12923   float arg1 ;
12924   float arg2 ;
12925   float arg3 ;
12926   float result;
12927
12928   arg1 = (float)jarg1;
12929   arg2 = (float)jarg2;
12930   arg3 = (float)jarg3;
12931   {
12932     try {
12933       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12934     } catch (std::out_of_range& e) {
12935       {
12936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (std::exception& e) {
12939       {
12940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948   jresult = result;
12949   return jresult;
12950 }
12951
12952
12953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12954   float jresult ;
12955   float arg1 ;
12956   float arg2 ;
12957   float arg3 ;
12958   float arg4 ;
12959   float result;
12960
12961   arg1 = (float)jarg1;
12962   arg2 = (float)jarg2;
12963   arg3 = (float)jarg3;
12964   arg4 = (float)jarg4;
12965   {
12966     try {
12967       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12968     } catch (std::out_of_range& e) {
12969       {
12970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12971       };
12972     } catch (std::exception& e) {
12973       {
12974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12975       };
12976     } catch (...) {
12977       {
12978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12979       };
12980     }
12981   }
12982   jresult = result;
12983   return jresult;
12984 }
12985
12986
12987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12988   int jresult ;
12989   int result;
12990
12991   result = (int)(int)Dali::Property::INVALID_INDEX;
12992   jresult = result;
12993   return jresult;
12994 }
12995
12996
12997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12998   int jresult ;
12999   int result;
13000
13001   result = (int)(int)Dali::Property::INVALID_KEY;
13002   jresult = result;
13003   return jresult;
13004 }
13005
13006
13007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13008   int jresult ;
13009   int result;
13010
13011   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13012   jresult = result;
13013   return jresult;
13014 }
13015
13016
13017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13018   void * jresult ;
13019   Dali::Handle *arg1 = 0 ;
13020   Dali::Property::Index arg2 ;
13021   Dali::Property *result = 0 ;
13022
13023   arg1 = (Dali::Handle *)jarg1;
13024   if (!arg1) {
13025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13026     return 0;
13027   }
13028   arg2 = (Dali::Property::Index)jarg2;
13029   {
13030     try {
13031       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13039       };
13040     } catch (...) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13043       };
13044     }
13045   }
13046   jresult = (void *)result;
13047   return jresult;
13048 }
13049
13050
13051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13052   void * jresult ;
13053   Dali::Handle *arg1 = 0 ;
13054   Dali::Property::Index arg2 ;
13055   int arg3 ;
13056   Dali::Property *result = 0 ;
13057
13058   arg1 = (Dali::Handle *)jarg1;
13059   if (!arg1) {
13060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13061     return 0;
13062   }
13063   arg2 = (Dali::Property::Index)jarg2;
13064   arg3 = (int)jarg3;
13065   {
13066     try {
13067       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13068     } catch (std::out_of_range& e) {
13069       {
13070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (std::exception& e) {
13073       {
13074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (...) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13079       };
13080     }
13081   }
13082   jresult = (void *)result;
13083   return jresult;
13084 }
13085
13086
13087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13088   void * jresult ;
13089   Dali::Handle *arg1 = 0 ;
13090   std::string *arg2 = 0 ;
13091   Dali::Property *result = 0 ;
13092
13093   arg1 = (Dali::Handle *)jarg1;
13094   if (!arg1) {
13095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13096     return 0;
13097   }
13098   if (!jarg2) {
13099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13100     return 0;
13101   }
13102   std::string arg2_str(jarg2);
13103   arg2 = &arg2_str;
13104   {
13105     try {
13106       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13107     } catch (std::out_of_range& e) {
13108       {
13109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (std::exception& e) {
13112       {
13113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121   jresult = (void *)result;
13122
13123   //argout typemap for const std::string&
13124
13125   return jresult;
13126 }
13127
13128
13129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13130   void * jresult ;
13131   Dali::Handle *arg1 = 0 ;
13132   std::string *arg2 = 0 ;
13133   int arg3 ;
13134   Dali::Property *result = 0 ;
13135
13136   arg1 = (Dali::Handle *)jarg1;
13137   if (!arg1) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13139     return 0;
13140   }
13141   if (!jarg2) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13143     return 0;
13144   }
13145   std::string arg2_str(jarg2);
13146   arg2 = &arg2_str;
13147   arg3 = (int)jarg3;
13148   {
13149     try {
13150       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13151     } catch (std::out_of_range& e) {
13152       {
13153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13154       };
13155     } catch (std::exception& e) {
13156       {
13157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13158       };
13159     } catch (...) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13162       };
13163     }
13164   }
13165   jresult = (void *)result;
13166
13167   //argout typemap for const std::string&
13168
13169   return jresult;
13170 }
13171
13172
13173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13174   Dali::Property *arg1 = (Dali::Property *) 0 ;
13175
13176   arg1 = (Dali::Property *)jarg1;
13177   {
13178     try {
13179       delete arg1;
13180     } catch (std::out_of_range& e) {
13181       {
13182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13183       };
13184     } catch (std::exception& e) {
13185       {
13186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13187       };
13188     } catch (...) {
13189       {
13190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13191       };
13192     }
13193   }
13194 }
13195
13196
13197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13198   Dali::Property *arg1 = (Dali::Property *) 0 ;
13199   Dali::Handle *arg2 = 0 ;
13200
13201   arg1 = (Dali::Property *)jarg1;
13202   arg2 = (Dali::Handle *)jarg2;
13203   if (!arg2) {
13204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13205     return ;
13206   }
13207   if (arg1) (arg1)->object = *arg2;
13208 }
13209
13210
13211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13212   void * jresult ;
13213   Dali::Property *arg1 = (Dali::Property *) 0 ;
13214   Dali::Handle *result = 0 ;
13215
13216   arg1 = (Dali::Property *)jarg1;
13217   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13218   jresult = (void *)result;
13219   return jresult;
13220 }
13221
13222
13223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13224   Dali::Property *arg1 = (Dali::Property *) 0 ;
13225   Dali::Property::Index arg2 ;
13226
13227   arg1 = (Dali::Property *)jarg1;
13228   arg2 = (Dali::Property::Index)jarg2;
13229   if (arg1) (arg1)->propertyIndex = arg2;
13230 }
13231
13232
13233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13234   int jresult ;
13235   Dali::Property *arg1 = (Dali::Property *) 0 ;
13236   Dali::Property::Index result;
13237
13238   arg1 = (Dali::Property *)jarg1;
13239   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13240   jresult = result;
13241   return jresult;
13242 }
13243
13244
13245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13246   Dali::Property *arg1 = (Dali::Property *) 0 ;
13247   int arg2 ;
13248
13249   arg1 = (Dali::Property *)jarg1;
13250   arg2 = (int)jarg2;
13251   if (arg1) (arg1)->componentIndex = arg2;
13252 }
13253
13254
13255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13256   int jresult ;
13257   Dali::Property *arg1 = (Dali::Property *) 0 ;
13258   int result;
13259
13260   arg1 = (Dali::Property *)jarg1;
13261   result = (int) ((arg1)->componentIndex);
13262   jresult = result;
13263   return jresult;
13264 }
13265
13266
13267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13268   void * jresult ;
13269   Dali::Property::Array *result = 0 ;
13270
13271   {
13272     try {
13273       result = (Dali::Property::Array *)new Dali::Property::Array();
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 (...) {
13283       {
13284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13285       };
13286     }
13287   }
13288   jresult = (void *)result;
13289   return jresult;
13290 }
13291
13292
13293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13294   void * jresult ;
13295   Dali::Property::Array *arg1 = 0 ;
13296   Dali::Property::Array *result = 0 ;
13297
13298   arg1 = (Dali::Property::Array *)jarg1;
13299   if (!arg1) {
13300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13301     return 0;
13302   }
13303   {
13304     try {
13305       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13306     } catch (std::out_of_range& e) {
13307       {
13308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13309       };
13310     } catch (std::exception& e) {
13311       {
13312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13313       };
13314     } catch (...) {
13315       {
13316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13317       };
13318     }
13319   }
13320   jresult = (void *)result;
13321   return jresult;
13322 }
13323
13324
13325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13326   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13327
13328   arg1 = (Dali::Property::Array *)jarg1;
13329   {
13330     try {
13331       delete arg1;
13332     } catch (std::out_of_range& e) {
13333       {
13334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13335       };
13336     } catch (std::exception& e) {
13337       {
13338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13339       };
13340     } catch (...) {
13341       {
13342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13343       };
13344     }
13345   }
13346 }
13347
13348
13349 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13350   unsigned long jresult ;
13351   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13352   Dali::Property::Array::SizeType result;
13353
13354   arg1 = (Dali::Property::Array *)jarg1;
13355   {
13356     try {
13357       result = ((Dali::Property::Array const *)arg1)->Size();
13358     } catch (std::out_of_range& e) {
13359       {
13360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13361       };
13362     } catch (std::exception& e) {
13363       {
13364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13365       };
13366     } catch (...) {
13367       {
13368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13369       };
13370     }
13371   }
13372   jresult = (unsigned long)result;
13373   return jresult;
13374 }
13375
13376
13377 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13378   unsigned long jresult ;
13379   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13380   Dali::Property::Array::SizeType result;
13381
13382   arg1 = (Dali::Property::Array *)jarg1;
13383   {
13384     try {
13385       result = ((Dali::Property::Array const *)arg1)->Count();
13386     } catch (std::out_of_range& e) {
13387       {
13388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13389       };
13390     } catch (std::exception& e) {
13391       {
13392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13393       };
13394     } catch (...) {
13395       {
13396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13397       };
13398     }
13399   }
13400   jresult = (unsigned long)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13406   unsigned int jresult ;
13407   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13408   bool result;
13409
13410   arg1 = (Dali::Property::Array *)jarg1;
13411   {
13412     try {
13413       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (...) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13425       };
13426     }
13427   }
13428   jresult = result;
13429   return jresult;
13430 }
13431
13432
13433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13434   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13435
13436   arg1 = (Dali::Property::Array *)jarg1;
13437   {
13438     try {
13439       (arg1)->Clear();
13440     } catch (std::out_of_range& e) {
13441       {
13442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13443       };
13444     } catch (std::exception& e) {
13445       {
13446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13447       };
13448     } catch (...) {
13449       {
13450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13451       };
13452     }
13453   }
13454 }
13455
13456
13457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13458   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13459   Dali::Property::Array::SizeType arg2 ;
13460
13461   arg1 = (Dali::Property::Array *)jarg1;
13462   arg2 = (Dali::Property::Array::SizeType)jarg2;
13463   {
13464     try {
13465       (arg1)->Reserve(arg2);
13466     } catch (std::out_of_range& e) {
13467       {
13468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13469       };
13470     } catch (std::exception& e) {
13471       {
13472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13473       };
13474     } catch (...) {
13475       {
13476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13477       };
13478     }
13479   }
13480 }
13481
13482
13483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13484   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13485   Dali::Property::Array::SizeType arg2 ;
13486
13487   arg1 = (Dali::Property::Array *)jarg1;
13488   arg2 = (Dali::Property::Array::SizeType)jarg2;
13489   {
13490     try {
13491       (arg1)->Resize(arg2);
13492     } catch (std::out_of_range& e) {
13493       {
13494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13495       };
13496     } catch (std::exception& e) {
13497       {
13498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13503       };
13504     }
13505   }
13506 }
13507
13508
13509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13510   unsigned long jresult ;
13511   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13512   Dali::Property::Array::SizeType result;
13513
13514   arg1 = (Dali::Property::Array *)jarg1;
13515   {
13516     try {
13517       result = (arg1)->Capacity();
13518     } catch (std::out_of_range& e) {
13519       {
13520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13521       };
13522     } catch (std::exception& e) {
13523       {
13524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13525       };
13526     } catch (...) {
13527       {
13528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13529       };
13530     }
13531   }
13532   jresult = (unsigned long)result;
13533   return jresult;
13534 }
13535
13536
13537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13538   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13539   Dali::Property::Value *arg2 = 0 ;
13540
13541   arg1 = (Dali::Property::Array *)jarg1;
13542   arg2 = (Dali::Property::Value *)jarg2;
13543   if (!arg2) {
13544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13545     return ;
13546   }
13547   {
13548     try {
13549       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13550     } catch (std::out_of_range& e) {
13551       {
13552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13553       };
13554     } catch (std::exception& e) {
13555       {
13556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13557       };
13558     } catch (...) {
13559       {
13560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13561       };
13562     }
13563   }
13564 }
13565
13566
13567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13568   void * jresult ;
13569   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13570   Dali::Property::Value *arg2 = 0 ;
13571   Dali::Property::Array *result = 0 ;
13572
13573   arg1 = (Dali::Property::Array *)jarg1;
13574   arg2 = (Dali::Property::Value *)jarg2;
13575   if (!arg2) {
13576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13577     return 0;
13578   }
13579   {
13580     try {
13581       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13582     } catch (std::out_of_range& e) {
13583       {
13584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13585       };
13586     } catch (std::exception& e) {
13587       {
13588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13589       };
13590     } catch (...) {
13591       {
13592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13593       };
13594     }
13595   }
13596   jresult = (void *)result;
13597   return jresult;
13598 }
13599
13600
13601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13602   void * jresult ;
13603   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13604   Dali::Property::Array::SizeType arg2 ;
13605   Dali::Property::Value *result = 0 ;
13606
13607   arg1 = (Dali::Property::Array *)jarg1;
13608   arg2 = (Dali::Property::Array::SizeType)jarg2;
13609   {
13610     try {
13611       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13612     } catch (std::out_of_range& e) {
13613       {
13614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13615       };
13616     } catch (std::exception& e) {
13617       {
13618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13619       };
13620     } catch (...) {
13621       {
13622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13623       };
13624     }
13625   }
13626   jresult = (void *)result;
13627   return jresult;
13628 }
13629
13630
13631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13632   void * jresult ;
13633   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13634   Dali::Property::Array::SizeType arg2 ;
13635   Dali::Property::Value *result = 0 ;
13636
13637   arg1 = (Dali::Property::Array *)jarg1;
13638   arg2 = (Dali::Property::Array::SizeType)jarg2;
13639   {
13640     try {
13641       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13642     } catch (std::out_of_range& e) {
13643       {
13644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13645       };
13646     } catch (std::exception& e) {
13647       {
13648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (...) {
13651       {
13652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13653       };
13654     }
13655   }
13656   jresult = (void *)result;
13657   return jresult;
13658 }
13659
13660
13661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13662   void * jresult ;
13663   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13664   Dali::Property::Array *arg2 = 0 ;
13665   Dali::Property::Array *result = 0 ;
13666
13667   arg1 = (Dali::Property::Array *)jarg1;
13668   arg2 = (Dali::Property::Array *)jarg2;
13669   if (!arg2) {
13670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13671     return 0;
13672   }
13673   {
13674     try {
13675       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13676     } catch (std::out_of_range& e) {
13677       {
13678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13679       };
13680     } catch (std::exception& e) {
13681       {
13682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13683       };
13684     } catch (...) {
13685       {
13686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13687       };
13688     }
13689   }
13690   jresult = (void *)result;
13691   return jresult;
13692 }
13693
13694
13695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13696   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13697   enum Dali::Property::Key::Type arg2 ;
13698
13699   arg1 = (Dali::Property::Key *)jarg1;
13700   arg2 = (enum Dali::Property::Key::Type)jarg2;
13701   if (arg1) (arg1)->type = arg2;
13702 }
13703
13704
13705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13706   int jresult ;
13707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13708   enum Dali::Property::Key::Type result;
13709
13710   arg1 = (Dali::Property::Key *)jarg1;
13711   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13712   jresult = (int)result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13718   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13719   Dali::Property::Index arg2 ;
13720
13721   arg1 = (Dali::Property::Key *)jarg1;
13722   arg2 = (Dali::Property::Index)jarg2;
13723   if (arg1) (arg1)->indexKey = arg2;
13724 }
13725
13726
13727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13728   int jresult ;
13729   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13730   Dali::Property::Index result;
13731
13732   arg1 = (Dali::Property::Key *)jarg1;
13733   result = (Dali::Property::Index) ((arg1)->indexKey);
13734   jresult = result;
13735   return jresult;
13736 }
13737
13738
13739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13740   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13741   std::string *arg2 = 0 ;
13742
13743   arg1 = (Dali::Property::Key *)jarg1;
13744   if (!jarg2) {
13745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13746     return ;
13747   }
13748   std::string arg2_str(jarg2);
13749   arg2 = &arg2_str;
13750   if (arg1) (arg1)->stringKey = *arg2;
13751
13752   //argout typemap for const std::string&
13753
13754 }
13755
13756
13757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13758   char * jresult ;
13759   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13760   std::string *result = 0 ;
13761
13762   arg1 = (Dali::Property::Key *)jarg1;
13763   result = (std::string *) & ((arg1)->stringKey);
13764   jresult = SWIG_csharp_string_callback(result->c_str());
13765   return jresult;
13766 }
13767
13768
13769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13770   void * jresult ;
13771   std::string *arg1 = 0 ;
13772   Dali::Property::Key *result = 0 ;
13773
13774   if (!jarg1) {
13775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13776     return 0;
13777   }
13778   std::string arg1_str(jarg1);
13779   arg1 = &arg1_str;
13780   {
13781     try {
13782       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13783     } catch (std::out_of_range& e) {
13784       {
13785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13786       };
13787     } catch (std::exception& e) {
13788       {
13789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (...) {
13792       {
13793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13794       };
13795     }
13796   }
13797   jresult = (void *)result;
13798
13799   //argout typemap for const std::string&
13800
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13806   void * jresult ;
13807   Dali::Property::Index arg1 ;
13808   Dali::Property::Key *result = 0 ;
13809
13810   arg1 = (Dali::Property::Index)jarg1;
13811   {
13812     try {
13813       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13814     } catch (std::out_of_range& e) {
13815       {
13816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13817       };
13818     } catch (std::exception& e) {
13819       {
13820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (...) {
13823       {
13824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13825       };
13826     }
13827   }
13828   jresult = (void *)result;
13829   return jresult;
13830 }
13831
13832
13833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13834   unsigned int jresult ;
13835   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13836   std::string *arg2 = 0 ;
13837   bool result;
13838
13839   arg1 = (Dali::Property::Key *)jarg1;
13840   if (!jarg2) {
13841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13842     return 0;
13843   }
13844   std::string arg2_str(jarg2);
13845   arg2 = &arg2_str;
13846   {
13847     try {
13848       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13849     } catch (std::out_of_range& e) {
13850       {
13851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13852       };
13853     } catch (std::exception& e) {
13854       {
13855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (...) {
13858       {
13859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13860       };
13861     }
13862   }
13863   jresult = result;
13864
13865   //argout typemap for const std::string&
13866
13867   return jresult;
13868 }
13869
13870
13871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13872   unsigned int jresult ;
13873   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13874   Dali::Property::Index arg2 ;
13875   bool result;
13876
13877   arg1 = (Dali::Property::Key *)jarg1;
13878   arg2 = (Dali::Property::Index)jarg2;
13879   {
13880     try {
13881       result = (bool)(arg1)->operator ==(arg2);
13882     } catch (std::out_of_range& e) {
13883       {
13884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13885       };
13886     } catch (std::exception& e) {
13887       {
13888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13889       };
13890     } catch (...) {
13891       {
13892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13893       };
13894     }
13895   }
13896   jresult = result;
13897   return jresult;
13898 }
13899
13900
13901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13902   unsigned int jresult ;
13903   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13904   Dali::Property::Key *arg2 = 0 ;
13905   bool result;
13906
13907   arg1 = (Dali::Property::Key *)jarg1;
13908   arg2 = (Dali::Property::Key *)jarg2;
13909   if (!arg2) {
13910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13911     return 0;
13912   }
13913   {
13914     try {
13915       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13916     } catch (std::out_of_range& e) {
13917       {
13918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (std::exception& e) {
13921       {
13922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13923       };
13924     } catch (...) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13927       };
13928     }
13929   }
13930   jresult = result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13936   unsigned int jresult ;
13937   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13938   std::string *arg2 = 0 ;
13939   bool result;
13940
13941   arg1 = (Dali::Property::Key *)jarg1;
13942   if (!jarg2) {
13943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13944     return 0;
13945   }
13946   std::string arg2_str(jarg2);
13947   arg2 = &arg2_str;
13948   {
13949     try {
13950       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13951     } catch (std::out_of_range& e) {
13952       {
13953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (std::exception& e) {
13956       {
13957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965   jresult = result;
13966
13967   //argout typemap for const std::string&
13968
13969   return jresult;
13970 }
13971
13972
13973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13974   unsigned int jresult ;
13975   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13976   Dali::Property::Index arg2 ;
13977   bool result;
13978
13979   arg1 = (Dali::Property::Key *)jarg1;
13980   arg2 = (Dali::Property::Index)jarg2;
13981   {
13982     try {
13983       result = (bool)(arg1)->operator !=(arg2);
13984     } catch (std::out_of_range& e) {
13985       {
13986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13987       };
13988     } catch (std::exception& e) {
13989       {
13990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13991       };
13992     } catch (...) {
13993       {
13994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13995       };
13996     }
13997   }
13998   jresult = result;
13999   return jresult;
14000 }
14001
14002
14003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14004   unsigned int jresult ;
14005   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14006   Dali::Property::Key *arg2 = 0 ;
14007   bool result;
14008
14009   arg1 = (Dali::Property::Key *)jarg1;
14010   arg2 = (Dali::Property::Key *)jarg2;
14011   if (!arg2) {
14012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14013     return 0;
14014   }
14015   {
14016     try {
14017       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14018     } catch (std::out_of_range& e) {
14019       {
14020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14021       };
14022     } catch (std::exception& e) {
14023       {
14024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14025       };
14026     } catch (...) {
14027       {
14028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14029       };
14030     }
14031   }
14032   jresult = result;
14033   return jresult;
14034 }
14035
14036
14037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14038   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14039
14040   arg1 = (Dali::Property::Key *)jarg1;
14041   {
14042     try {
14043       delete arg1;
14044     } catch (std::out_of_range& e) {
14045       {
14046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14047       };
14048     } catch (std::exception& e) {
14049       {
14050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14051       };
14052     } catch (...) {
14053       {
14054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14055       };
14056     }
14057   }
14058 }
14059
14060
14061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14062   void * jresult ;
14063   Dali::Property::Map *result = 0 ;
14064
14065   {
14066     try {
14067       result = (Dali::Property::Map *)new Dali::Property::Map();
14068     } catch (std::out_of_range& e) {
14069       {
14070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14071       };
14072     } catch (std::exception& e) {
14073       {
14074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14075       };
14076     } catch (...) {
14077       {
14078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14079       };
14080     }
14081   }
14082   jresult = (void *)result;
14083   return jresult;
14084 }
14085
14086
14087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14088   void * jresult ;
14089   Dali::Property::Map *arg1 = 0 ;
14090   Dali::Property::Map *result = 0 ;
14091
14092   arg1 = (Dali::Property::Map *)jarg1;
14093   if (!arg1) {
14094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14095     return 0;
14096   }
14097   {
14098     try {
14099       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14100     } catch (std::out_of_range& e) {
14101       {
14102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14103       };
14104     } catch (std::exception& e) {
14105       {
14106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14107       };
14108     } catch (...) {
14109       {
14110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14111       };
14112     }
14113   }
14114   jresult = (void *)result;
14115   return jresult;
14116 }
14117
14118
14119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14120   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14121
14122   arg1 = (Dali::Property::Map *)jarg1;
14123   {
14124     try {
14125       delete arg1;
14126     } catch (std::out_of_range& e) {
14127       {
14128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14129       };
14130     } catch (std::exception& e) {
14131       {
14132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14133       };
14134     } catch (...) {
14135       {
14136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14137       };
14138     }
14139   }
14140 }
14141
14142
14143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14144   unsigned long jresult ;
14145   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14146   Dali::Property::Map::SizeType result;
14147
14148   arg1 = (Dali::Property::Map *)jarg1;
14149   {
14150     try {
14151       result = ((Dali::Property::Map const *)arg1)->Count();
14152     } catch (std::out_of_range& e) {
14153       {
14154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14155       };
14156     } catch (std::exception& e) {
14157       {
14158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14159       };
14160     } catch (...) {
14161       {
14162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14163       };
14164     }
14165   }
14166   jresult = (unsigned long)result;
14167   return jresult;
14168 }
14169
14170
14171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14172   unsigned int jresult ;
14173   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14174   bool result;
14175
14176   arg1 = (Dali::Property::Map *)jarg1;
14177   {
14178     try {
14179       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14180     } catch (std::out_of_range& e) {
14181       {
14182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14183       };
14184     } catch (std::exception& e) {
14185       {
14186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14187       };
14188     } catch (...) {
14189       {
14190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14191       };
14192     }
14193   }
14194   jresult = result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14200   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14201   char *arg2 = (char *) 0 ;
14202   Dali::Property::Value *arg3 = 0 ;
14203
14204   arg1 = (Dali::Property::Map *)jarg1;
14205   arg2 = (char *)jarg2;
14206   arg3 = (Dali::Property::Value *)jarg3;
14207   if (!arg3) {
14208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14209     return ;
14210   }
14211   {
14212     try {
14213       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14214     } catch (std::out_of_range& e) {
14215       {
14216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14217       };
14218     } catch (std::exception& e) {
14219       {
14220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14221       };
14222     } catch (...) {
14223       {
14224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14225       };
14226     }
14227   }
14228 }
14229
14230
14231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14232   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14233   Dali::Property::Index arg2 ;
14234   Dali::Property::Value *arg3 = 0 ;
14235
14236   arg1 = (Dali::Property::Map *)jarg1;
14237   arg2 = (Dali::Property::Index)jarg2;
14238   arg3 = (Dali::Property::Value *)jarg3;
14239   if (!arg3) {
14240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14241     return ;
14242   }
14243   {
14244     try {
14245       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14246     } catch (std::out_of_range& e) {
14247       {
14248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14249       };
14250     } catch (std::exception& e) {
14251       {
14252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14253       };
14254     } catch (...) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14257       };
14258     }
14259   }
14260 }
14261
14262
14263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14264   void * jresult ;
14265   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14266   char *arg2 = (char *) 0 ;
14267   Dali::Property::Value *arg3 = 0 ;
14268   Dali::Property::Map *result = 0 ;
14269
14270   arg1 = (Dali::Property::Map *)jarg1;
14271   arg2 = (char *)jarg2;
14272   arg3 = (Dali::Property::Value *)jarg3;
14273   if (!arg3) {
14274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14275     return 0;
14276   }
14277   {
14278     try {
14279       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (...) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14291       };
14292     }
14293   }
14294   jresult = (void *)result;
14295   return jresult;
14296 }
14297
14298
14299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14300   void * jresult ;
14301   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14302   Dali::Property::Index arg2 ;
14303   Dali::Property::Value *arg3 = 0 ;
14304   Dali::Property::Map *result = 0 ;
14305
14306   arg1 = (Dali::Property::Map *)jarg1;
14307   arg2 = (Dali::Property::Index)jarg2;
14308   arg3 = (Dali::Property::Value *)jarg3;
14309   if (!arg3) {
14310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14311     return 0;
14312   }
14313   {
14314     try {
14315       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*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 (...) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14327       };
14328     }
14329   }
14330   jresult = (void *)result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14336   void * jresult ;
14337   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14338   Dali::Property::Map::SizeType arg2 ;
14339   Dali::Property::Value *result = 0 ;
14340
14341   arg1 = (Dali::Property::Map *)jarg1;
14342   arg2 = (Dali::Property::Map::SizeType)jarg2;
14343   {
14344     try {
14345       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14346     } catch (std::out_of_range& e) {
14347       {
14348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14349       };
14350     } catch (std::exception& e) {
14351       {
14352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14353       };
14354     } catch (...) {
14355       {
14356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14357       };
14358     }
14359   }
14360   jresult = (void *)result;
14361   return jresult;
14362 }
14363
14364
14365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14366   char * jresult ;
14367   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14368   Dali::Property::Map::SizeType arg2 ;
14369   std::string *result = 0 ;
14370
14371   arg1 = (Dali::Property::Map *)jarg1;
14372   arg2 = (Dali::Property::Map::SizeType)jarg2;
14373   {
14374     try {
14375       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14376     } catch (std::out_of_range& e) {
14377       {
14378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14379       };
14380     } catch (std::exception& e) {
14381       {
14382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14383       };
14384     } catch (...) {
14385       {
14386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14387       };
14388     }
14389   }
14390   jresult = SWIG_csharp_string_callback(result->c_str());
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14396   void * jresult ;
14397   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14398   Dali::Property::Map::SizeType arg2 ;
14399   SwigValueWrapper< Dali::Property::Key > result;
14400
14401   arg1 = (Dali::Property::Map *)jarg1;
14402   arg2 = (Dali::Property::Map::SizeType)jarg2;
14403   {
14404     try {
14405       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14406     } catch (std::out_of_range& e) {
14407       {
14408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14409       };
14410     } catch (std::exception& e) {
14411       {
14412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14413       };
14414     } catch (...) {
14415       {
14416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14417       };
14418     }
14419   }
14420   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14421   return jresult;
14422 }
14423
14424
14425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14426   void * jresult ;
14427   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14428   Dali::Property::Map::SizeType arg2 ;
14429   StringValuePair *result = 0 ;
14430
14431   arg1 = (Dali::Property::Map *)jarg1;
14432   arg2 = (Dali::Property::Map::SizeType)jarg2;
14433   {
14434     try {
14435       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14436     } catch (std::out_of_range& e) {
14437       {
14438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14439       };
14440     } catch (std::exception& e) {
14441       {
14442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14443       };
14444     } catch (...) {
14445       {
14446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14447       };
14448     }
14449   }
14450   jresult = (void *)result;
14451   return jresult;
14452 }
14453
14454
14455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14456   void * jresult ;
14457   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14458   char *arg2 = (char *) 0 ;
14459   Dali::Property::Value *result = 0 ;
14460
14461   arg1 = (Dali::Property::Map *)jarg1;
14462   arg2 = (char *)jarg2;
14463   {
14464     try {
14465       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14466     } catch (std::out_of_range& e) {
14467       {
14468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14469       };
14470     } catch (std::exception& e) {
14471       {
14472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14473       };
14474     } catch (...) {
14475       {
14476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14477       };
14478     }
14479   }
14480   jresult = (void *)result;
14481   return jresult;
14482 }
14483
14484
14485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14486   void * jresult ;
14487   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14488   Dali::Property::Index arg2 ;
14489   Dali::Property::Value *result = 0 ;
14490
14491   arg1 = (Dali::Property::Map *)jarg1;
14492   arg2 = (Dali::Property::Index)jarg2;
14493   {
14494     try {
14495       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(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 (...) {
14505       {
14506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14507       };
14508     }
14509   }
14510   jresult = (void *)result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14516   void * jresult ;
14517   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14518   Dali::Property::Index arg2 ;
14519   std::string *arg3 = 0 ;
14520   Dali::Property::Value *result = 0 ;
14521
14522   arg1 = (Dali::Property::Map *)jarg1;
14523   arg2 = (Dali::Property::Index)jarg2;
14524   if (!jarg3) {
14525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14526     return 0;
14527   }
14528   std::string arg3_str(jarg3);
14529   arg3 = &arg3_str;
14530   {
14531     try {
14532       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14533     } catch (std::out_of_range& e) {
14534       {
14535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14536       };
14537     } catch (std::exception& e) {
14538       {
14539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14540       };
14541     } catch (...) {
14542       {
14543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14544       };
14545     }
14546   }
14547   jresult = (void *)result;
14548
14549   //argout typemap for const std::string&
14550
14551   return jresult;
14552 }
14553
14554
14555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14556   void * jresult ;
14557   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14558   std::string *arg2 = 0 ;
14559   Dali::Property::Type arg3 ;
14560   Dali::Property::Value *result = 0 ;
14561
14562   arg1 = (Dali::Property::Map *)jarg1;
14563   if (!jarg2) {
14564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14565     return 0;
14566   }
14567   std::string arg2_str(jarg2);
14568   arg2 = &arg2_str;
14569   arg3 = (Dali::Property::Type)jarg3;
14570   {
14571     try {
14572       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14573     } catch (std::out_of_range& e) {
14574       {
14575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14576       };
14577     } catch (std::exception& e) {
14578       {
14579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14580       };
14581     } catch (...) {
14582       {
14583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14584       };
14585     }
14586   }
14587   jresult = (void *)result;
14588
14589   //argout typemap for const std::string&
14590
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14596   void * jresult ;
14597   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14598   Dali::Property::Index arg2 ;
14599   Dali::Property::Type arg3 ;
14600   Dali::Property::Value *result = 0 ;
14601
14602   arg1 = (Dali::Property::Map *)jarg1;
14603   arg2 = (Dali::Property::Index)jarg2;
14604   arg3 = (Dali::Property::Type)jarg3;
14605   {
14606     try {
14607       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14608     } catch (std::out_of_range& e) {
14609       {
14610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14611       };
14612     } catch (std::exception& e) {
14613       {
14614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14615       };
14616     } catch (...) {
14617       {
14618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14619       };
14620     }
14621   }
14622   jresult = (void *)result;
14623   return jresult;
14624 }
14625
14626
14627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14628   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14629
14630   arg1 = (Dali::Property::Map *)jarg1;
14631   {
14632     try {
14633       (arg1)->Clear();
14634     } catch (std::out_of_range& e) {
14635       {
14636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14637       };
14638     } catch (std::exception& e) {
14639       {
14640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14645       };
14646     }
14647   }
14648 }
14649
14650
14651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14652   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14653   Dali::Property::Map *arg2 = 0 ;
14654
14655   arg1 = (Dali::Property::Map *)jarg1;
14656   arg2 = (Dali::Property::Map *)jarg2;
14657   if (!arg2) {
14658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14659     return ;
14660   }
14661   {
14662     try {
14663       (arg1)->Merge((Dali::Property::Map const &)*arg2);
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 (...) {
14673       {
14674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14675       };
14676     }
14677   }
14678 }
14679
14680
14681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14682   void * jresult ;
14683   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14684   std::string *arg2 = 0 ;
14685   Dali::Property::Value *result = 0 ;
14686
14687   arg1 = (Dali::Property::Map *)jarg1;
14688   if (!jarg2) {
14689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14690     return 0;
14691   }
14692   std::string arg2_str(jarg2);
14693   arg2 = &arg2_str;
14694   {
14695     try {
14696       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14697     } catch (std::out_of_range& e) {
14698       {
14699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14700       };
14701     } catch (std::exception& e) {
14702       {
14703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14704       };
14705     } catch (...) {
14706       {
14707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14708       };
14709     }
14710   }
14711   jresult = (void *)result;
14712
14713   //argout typemap for const std::string&
14714
14715   return jresult;
14716 }
14717
14718
14719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14720   void * jresult ;
14721   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14722   Dali::Property::Index arg2 ;
14723   Dali::Property::Value *result = 0 ;
14724
14725   arg1 = (Dali::Property::Map *)jarg1;
14726   arg2 = (Dali::Property::Index)jarg2;
14727   {
14728     try {
14729       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14730     } catch (std::out_of_range& e) {
14731       {
14732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14733       };
14734     } catch (std::exception& e) {
14735       {
14736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14737       };
14738     } catch (...) {
14739       {
14740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14741       };
14742     }
14743   }
14744   jresult = (void *)result;
14745   return jresult;
14746 }
14747
14748
14749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14750   void * jresult ;
14751   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14752   Dali::Property::Map *arg2 = 0 ;
14753   Dali::Property::Map *result = 0 ;
14754
14755   arg1 = (Dali::Property::Map *)jarg1;
14756   arg2 = (Dali::Property::Map *)jarg2;
14757   if (!arg2) {
14758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14759     return 0;
14760   }
14761   {
14762     try {
14763       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14764     } catch (std::out_of_range& e) {
14765       {
14766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14767       };
14768     } catch (std::exception& e) {
14769       {
14770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (...) {
14773       {
14774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14775       };
14776     }
14777   }
14778   jresult = (void *)result;
14779   return jresult;
14780 }
14781
14782
14783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14784   void * jresult ;
14785   Dali::Property::Value *result = 0 ;
14786
14787   {
14788     try {
14789       result = (Dali::Property::Value *)new Dali::Property::Value();
14790     } catch (std::out_of_range& e) {
14791       {
14792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14793       };
14794     } catch (std::exception& e) {
14795       {
14796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14797       };
14798     } catch (...) {
14799       {
14800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14801       };
14802     }
14803   }
14804   jresult = (void *)result;
14805   return jresult;
14806 }
14807
14808
14809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14810   void * jresult ;
14811   bool arg1 ;
14812   Dali::Property::Value *result = 0 ;
14813
14814   arg1 = jarg1 ? true : false;
14815   {
14816     try {
14817       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14818     } catch (std::out_of_range& e) {
14819       {
14820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14821       };
14822     } catch (std::exception& e) {
14823       {
14824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14825       };
14826     } catch (...) {
14827       {
14828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14829       };
14830     }
14831   }
14832   jresult = (void *)result;
14833   return jresult;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14838   void * jresult ;
14839   int arg1 ;
14840   Dali::Property::Value *result = 0 ;
14841
14842   arg1 = (int)jarg1;
14843   {
14844     try {
14845       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14846     } catch (std::out_of_range& e) {
14847       {
14848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14849       };
14850     } catch (std::exception& e) {
14851       {
14852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14853       };
14854     } catch (...) {
14855       {
14856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14857       };
14858     }
14859   }
14860   jresult = (void *)result;
14861   return jresult;
14862 }
14863
14864
14865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14866   void * jresult ;
14867   float arg1 ;
14868   Dali::Property::Value *result = 0 ;
14869
14870   arg1 = (float)jarg1;
14871   {
14872     try {
14873       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14874     } catch (std::out_of_range& e) {
14875       {
14876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (std::exception& e) {
14879       {
14880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14881       };
14882     } catch (...) {
14883       {
14884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14885       };
14886     }
14887   }
14888   jresult = (void *)result;
14889   return jresult;
14890 }
14891
14892
14893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14894   void * jresult ;
14895   Dali::Vector2 *arg1 = 0 ;
14896   Dali::Property::Value *result = 0 ;
14897
14898   arg1 = (Dali::Vector2 *)jarg1;
14899   if (!arg1) {
14900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14901     return 0;
14902   }
14903   {
14904     try {
14905       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14906     } catch (std::out_of_range& e) {
14907       {
14908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14909       };
14910     } catch (std::exception& e) {
14911       {
14912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14913       };
14914     } catch (...) {
14915       {
14916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14917       };
14918     }
14919   }
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14926   void * jresult ;
14927   Dali::Vector3 *arg1 = 0 ;
14928   Dali::Property::Value *result = 0 ;
14929
14930   arg1 = (Dali::Vector3 *)jarg1;
14931   if (!arg1) {
14932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14933     return 0;
14934   }
14935   {
14936     try {
14937       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (...) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14949       };
14950     }
14951   }
14952   jresult = (void *)result;
14953   return jresult;
14954 }
14955
14956
14957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14958   void * jresult ;
14959   Dali::Vector4 *arg1 = 0 ;
14960   Dali::Property::Value *result = 0 ;
14961
14962   arg1 = (Dali::Vector4 *)jarg1;
14963   if (!arg1) {
14964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14965     return 0;
14966   }
14967   {
14968     try {
14969       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14970     } catch (std::out_of_range& e) {
14971       {
14972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14973       };
14974     } catch (std::exception& e) {
14975       {
14976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14977       };
14978     } catch (...) {
14979       {
14980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14981       };
14982     }
14983   }
14984   jresult = (void *)result;
14985   return jresult;
14986 }
14987
14988
14989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14990   void * jresult ;
14991   Dali::Matrix3 *arg1 = 0 ;
14992   Dali::Property::Value *result = 0 ;
14993
14994   arg1 = (Dali::Matrix3 *)jarg1;
14995   if (!arg1) {
14996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14997     return 0;
14998   }
14999   {
15000     try {
15001       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (...) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15013       };
15014     }
15015   }
15016   jresult = (void *)result;
15017   return jresult;
15018 }
15019
15020
15021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15022   void * jresult ;
15023   Dali::Matrix *arg1 = 0 ;
15024   Dali::Property::Value *result = 0 ;
15025
15026   arg1 = (Dali::Matrix *)jarg1;
15027   if (!arg1) {
15028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15029     return 0;
15030   }
15031   {
15032     try {
15033       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15034     } catch (std::out_of_range& e) {
15035       {
15036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (std::exception& e) {
15039       {
15040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15041       };
15042     } catch (...) {
15043       {
15044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15045       };
15046     }
15047   }
15048   jresult = (void *)result;
15049   return jresult;
15050 }
15051
15052
15053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15054   void * jresult ;
15055   Dali::Rect< int > *arg1 = 0 ;
15056   Dali::Property::Value *result = 0 ;
15057
15058   arg1 = (Dali::Rect< int > *)jarg1;
15059   if (!arg1) {
15060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15061     return 0;
15062   }
15063   {
15064     try {
15065       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (...) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15077       };
15078     }
15079   }
15080   jresult = (void *)result;
15081   return jresult;
15082 }
15083
15084
15085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15086   void * jresult ;
15087   Dali::AngleAxis *arg1 = 0 ;
15088   Dali::Property::Value *result = 0 ;
15089
15090   arg1 = (Dali::AngleAxis *)jarg1;
15091   if (!arg1) {
15092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15093     return 0;
15094   }
15095   {
15096     try {
15097       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15098     } catch (std::out_of_range& e) {
15099       {
15100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15101       };
15102     } catch (std::exception& e) {
15103       {
15104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15105       };
15106     } catch (...) {
15107       {
15108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15109       };
15110     }
15111   }
15112   jresult = (void *)result;
15113   return jresult;
15114 }
15115
15116
15117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15118   void * jresult ;
15119   Dali::Quaternion *arg1 = 0 ;
15120   Dali::Property::Value *result = 0 ;
15121
15122   arg1 = (Dali::Quaternion *)jarg1;
15123   if (!arg1) {
15124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15125     return 0;
15126   }
15127   {
15128     try {
15129       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15137       };
15138     } catch (...) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15141       };
15142     }
15143   }
15144   jresult = (void *)result;
15145   return jresult;
15146 }
15147
15148
15149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15150   void * jresult ;
15151   std::string *arg1 = 0 ;
15152   Dali::Property::Value *result = 0 ;
15153
15154   if (!jarg1) {
15155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15156     return 0;
15157   }
15158   std::string arg1_str(jarg1);
15159   arg1 = &arg1_str;
15160   {
15161     try {
15162       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15163     } catch (std::out_of_range& e) {
15164       {
15165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15166       };
15167     } catch (std::exception& e) {
15168       {
15169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15174       };
15175     }
15176   }
15177   jresult = (void *)result;
15178
15179   //argout typemap for const std::string&
15180
15181   return jresult;
15182 }
15183
15184
15185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15186   void * jresult ;
15187   Dali::Property::Array *arg1 = 0 ;
15188   Dali::Property::Value *result = 0 ;
15189
15190   arg1 = (Dali::Property::Array *)jarg1;
15191   if (!arg1) {
15192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15193     return 0;
15194   }
15195   {
15196     try {
15197       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15198     } catch (std::out_of_range& e) {
15199       {
15200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15201       };
15202     } catch (std::exception& e) {
15203       {
15204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15205       };
15206     } catch (...) {
15207       {
15208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15209       };
15210     }
15211   }
15212   jresult = (void *)result;
15213   return jresult;
15214 }
15215
15216
15217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15218   void * jresult ;
15219   Dali::Property::Map *arg1 = 0 ;
15220   Dali::Property::Value *result = 0 ;
15221
15222   arg1 = (Dali::Property::Map *)jarg1;
15223   if (!arg1) {
15224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15225     return 0;
15226   }
15227   {
15228     try {
15229       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15230     } catch (std::out_of_range& e) {
15231       {
15232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15233       };
15234     } catch (std::exception& e) {
15235       {
15236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15241       };
15242     }
15243   }
15244   jresult = (void *)result;
15245   return jresult;
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15250   void * jresult ;
15251   Dali::Property::Type arg1 ;
15252   Dali::Property::Value *result = 0 ;
15253
15254   arg1 = (Dali::Property::Type)jarg1;
15255   {
15256     try {
15257       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15258     } catch (std::out_of_range& e) {
15259       {
15260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (std::exception& e) {
15263       {
15264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15265       };
15266     } catch (...) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15269       };
15270     }
15271   }
15272   jresult = (void *)result;
15273   return jresult;
15274 }
15275
15276
15277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15278   void * jresult ;
15279   Dali::Property::Value *arg1 = 0 ;
15280   Dali::Property::Value *result = 0 ;
15281
15282   arg1 = (Dali::Property::Value *)jarg1;
15283   if (!arg1) {
15284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15285     return 0;
15286   }
15287   {
15288     try {
15289       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15290     } catch (std::out_of_range& e) {
15291       {
15292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15293       };
15294     } catch (std::exception& e) {
15295       {
15296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15297       };
15298     } catch (...) {
15299       {
15300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15301       };
15302     }
15303   }
15304   jresult = (void *)result;
15305   return jresult;
15306 }
15307
15308
15309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15310   void * jresult ;
15311   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15312   Dali::Property::Value *arg2 = 0 ;
15313   Dali::Property::Value *result = 0 ;
15314
15315   arg1 = (Dali::Property::Value *)jarg1;
15316   arg2 = (Dali::Property::Value *)jarg2;
15317   if (!arg2) {
15318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15319     return 0;
15320   }
15321   {
15322     try {
15323       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15324     } catch (std::out_of_range& e) {
15325       {
15326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15327       };
15328     } catch (std::exception& e) {
15329       {
15330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (...) {
15333       {
15334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15335       };
15336     }
15337   }
15338   jresult = (void *)result;
15339   return jresult;
15340 }
15341
15342
15343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15344   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15345
15346   arg1 = (Dali::Property::Value *)jarg1;
15347   {
15348     try {
15349       delete arg1;
15350     } catch (std::out_of_range& e) {
15351       {
15352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15353       };
15354     } catch (std::exception& e) {
15355       {
15356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15357       };
15358     } catch (...) {
15359       {
15360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15361       };
15362     }
15363   }
15364 }
15365
15366
15367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15368   int jresult ;
15369   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15370   Dali::Property::Type result;
15371
15372   arg1 = (Dali::Property::Value *)jarg1;
15373   {
15374     try {
15375       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15376     } catch (std::out_of_range& e) {
15377       {
15378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15379       };
15380     } catch (std::exception& e) {
15381       {
15382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15383       };
15384     } catch (...) {
15385       {
15386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15387       };
15388     }
15389   }
15390   jresult = (int)result;
15391   return jresult;
15392 }
15393
15394
15395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15396   unsigned int jresult ;
15397   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15398   bool *arg2 = 0 ;
15399   bool result;
15400
15401   arg1 = (Dali::Property::Value *)jarg1;
15402   arg2 = (bool *)jarg2;
15403   {
15404     try {
15405       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15406     } catch (std::out_of_range& e) {
15407       {
15408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15409       };
15410     } catch (std::exception& e) {
15411       {
15412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15413       };
15414     } catch (...) {
15415       {
15416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15417       };
15418     }
15419   }
15420   jresult = result;
15421   return jresult;
15422 }
15423
15424
15425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15426   unsigned int jresult ;
15427   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15428   float *arg2 = 0 ;
15429   bool result;
15430
15431   arg1 = (Dali::Property::Value *)jarg1;
15432   arg2 = (float *)jarg2;
15433   {
15434     try {
15435       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15436     } catch (std::out_of_range& e) {
15437       {
15438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15439       };
15440     } catch (std::exception& e) {
15441       {
15442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (...) {
15445       {
15446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15447       };
15448     }
15449   }
15450   jresult = result;
15451   return jresult;
15452 }
15453
15454
15455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15456   unsigned int jresult ;
15457   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15458   int *arg2 = 0 ;
15459   bool result;
15460
15461   arg1 = (Dali::Property::Value *)jarg1;
15462   arg2 = (int *)jarg2;
15463   {
15464     try {
15465       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15466     } catch (std::out_of_range& e) {
15467       {
15468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15469       };
15470     } catch (std::exception& e) {
15471       {
15472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15473       };
15474     } catch (...) {
15475       {
15476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15477       };
15478     }
15479   }
15480   jresult = result;
15481   return jresult;
15482 }
15483
15484
15485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15486   unsigned int jresult ;
15487   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15488   Dali::Rect< int > *arg2 = 0 ;
15489   bool result;
15490
15491   arg1 = (Dali::Property::Value *)jarg1;
15492   arg2 = (Dali::Rect< int > *)jarg2;
15493   if (!arg2) {
15494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15495     return 0;
15496   }
15497   {
15498     try {
15499       result = (bool)((Dali::Property::Value const *)arg1)->Get(*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 (...) {
15509       {
15510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15511       };
15512     }
15513   }
15514   jresult = result;
15515   return jresult;
15516 }
15517
15518
15519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15520   unsigned int jresult ;
15521   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15522   Dali::Vector2 *arg2 = 0 ;
15523   bool result;
15524
15525   arg1 = (Dali::Property::Value *)jarg1;
15526   arg2 = (Dali::Vector2 *)jarg2;
15527   if (!arg2) {
15528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15529     return 0;
15530   }
15531   {
15532     try {
15533       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15534     } catch (std::out_of_range& e) {
15535       {
15536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15537       };
15538     } catch (std::exception& e) {
15539       {
15540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15541       };
15542     } catch (...) {
15543       {
15544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15545       };
15546     }
15547   }
15548   jresult = result;
15549   return jresult;
15550 }
15551
15552
15553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15554   unsigned int jresult ;
15555   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15556   Dali::Vector3 *arg2 = 0 ;
15557   bool result;
15558
15559   arg1 = (Dali::Property::Value *)jarg1;
15560   arg2 = (Dali::Vector3 *)jarg2;
15561   if (!arg2) {
15562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15563     return 0;
15564   }
15565   {
15566     try {
15567       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15568     } catch (std::out_of_range& e) {
15569       {
15570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15571       };
15572     } catch (std::exception& e) {
15573       {
15574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (...) {
15577       {
15578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15579       };
15580     }
15581   }
15582   jresult = result;
15583   return jresult;
15584 }
15585
15586
15587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15588   unsigned int jresult ;
15589   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15590   Dali::Vector4 *arg2 = 0 ;
15591   bool result;
15592
15593   arg1 = (Dali::Property::Value *)jarg1;
15594   arg2 = (Dali::Vector4 *)jarg2;
15595   if (!arg2) {
15596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15597     return 0;
15598   }
15599   {
15600     try {
15601       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15602     } catch (std::out_of_range& e) {
15603       {
15604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15605       };
15606     } catch (std::exception& e) {
15607       {
15608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15609       };
15610     } catch (...) {
15611       {
15612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15613       };
15614     }
15615   }
15616   jresult = result;
15617   return jresult;
15618 }
15619
15620
15621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15622   unsigned int jresult ;
15623   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15624   Dali::Matrix3 *arg2 = 0 ;
15625   bool result;
15626
15627   arg1 = (Dali::Property::Value *)jarg1;
15628   arg2 = (Dali::Matrix3 *)jarg2;
15629   if (!arg2) {
15630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15631     return 0;
15632   }
15633   {
15634     try {
15635       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15636     } catch (std::out_of_range& e) {
15637       {
15638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15639       };
15640     } catch (std::exception& e) {
15641       {
15642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (...) {
15645       {
15646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15647       };
15648     }
15649   }
15650   jresult = result;
15651   return jresult;
15652 }
15653
15654
15655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15656   unsigned int jresult ;
15657   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15658   Dali::Matrix *arg2 = 0 ;
15659   bool result;
15660
15661   arg1 = (Dali::Property::Value *)jarg1;
15662   arg2 = (Dali::Matrix *)jarg2;
15663   if (!arg2) {
15664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15665     return 0;
15666   }
15667   {
15668     try {
15669       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15670     } catch (std::out_of_range& e) {
15671       {
15672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15673       };
15674     } catch (std::exception& e) {
15675       {
15676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (...) {
15679       {
15680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15681       };
15682     }
15683   }
15684   jresult = result;
15685   return jresult;
15686 }
15687
15688
15689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15690   unsigned int jresult ;
15691   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15692   Dali::AngleAxis *arg2 = 0 ;
15693   bool result;
15694
15695   arg1 = (Dali::Property::Value *)jarg1;
15696   arg2 = (Dali::AngleAxis *)jarg2;
15697   if (!arg2) {
15698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15699     return 0;
15700   }
15701   {
15702     try {
15703       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15704     } catch (std::out_of_range& e) {
15705       {
15706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15707       };
15708     } catch (std::exception& e) {
15709       {
15710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15711       };
15712     } catch (...) {
15713       {
15714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15715       };
15716     }
15717   }
15718   jresult = result;
15719   return jresult;
15720 }
15721
15722
15723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15724   unsigned int jresult ;
15725   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15726   Dali::Quaternion *arg2 = 0 ;
15727   bool result;
15728
15729   arg1 = (Dali::Property::Value *)jarg1;
15730   arg2 = (Dali::Quaternion *)jarg2;
15731   if (!arg2) {
15732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15733     return 0;
15734   }
15735   {
15736     try {
15737       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15738     } catch (std::out_of_range& e) {
15739       {
15740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15741       };
15742     } catch (std::exception& e) {
15743       {
15744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15745       };
15746     } catch (...) {
15747       {
15748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15749       };
15750     }
15751   }
15752   jresult = result;
15753   return jresult;
15754 }
15755
15756
15757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15758   unsigned int jresult ;
15759   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15760   std::string *arg2 = 0 ;
15761   bool result;
15762
15763   arg1 = (Dali::Property::Value *)jarg1;
15764
15765   //typemap in
15766   std::string temp;
15767   arg2 = &temp;
15768
15769   {
15770     try {
15771       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15772     } catch (std::out_of_range& e) {
15773       {
15774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15775       };
15776     } catch (std::exception& e) {
15777       {
15778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15779       };
15780     } catch (...) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15783       };
15784     }
15785   }
15786   jresult = result;
15787
15788   //Typemap argout in c++ file.
15789   //This will convert c++ string to c# string
15790   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15791
15792   return jresult;
15793 }
15794
15795
15796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15797   unsigned int jresult ;
15798   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15799   Dali::Property::Array *arg2 = 0 ;
15800   bool result;
15801
15802   arg1 = (Dali::Property::Value *)jarg1;
15803   arg2 = (Dali::Property::Array *)jarg2;
15804   if (!arg2) {
15805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15806     return 0;
15807   }
15808   {
15809     try {
15810       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15811     } catch (std::out_of_range& e) {
15812       {
15813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (std::exception& e) {
15816       {
15817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15822       };
15823     }
15824   }
15825   jresult = result;
15826   return jresult;
15827 }
15828
15829
15830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15831   unsigned int jresult ;
15832   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15833   Dali::Property::Map *arg2 = 0 ;
15834   bool result;
15835
15836   arg1 = (Dali::Property::Value *)jarg1;
15837   arg2 = (Dali::Property::Map *)jarg2;
15838   if (!arg2) {
15839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15840     return 0;
15841   }
15842   {
15843     try {
15844       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15845     } catch (std::out_of_range& e) {
15846       {
15847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15848       };
15849     } catch (std::exception& e) {
15850       {
15851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15852       };
15853     } catch (...) {
15854       {
15855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15856       };
15857     }
15858   }
15859   jresult = result;
15860   return jresult;
15861 }
15862
15863
15864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15865   void * jresult ;
15866   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15867   Dali::Property::Array *result = 0 ;
15868
15869   arg1 = (Dali::Property::Value *)jarg1;
15870   {
15871     try {
15872       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15873     } catch (std::out_of_range& e) {
15874       {
15875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15876       };
15877     } catch (std::exception& e) {
15878       {
15879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15884       };
15885     }
15886   }
15887   jresult = (void *)result;
15888   return jresult;
15889 }
15890
15891
15892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15893   void * jresult ;
15894   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15895   Dali::Property::Map *result = 0 ;
15896
15897   arg1 = (Dali::Property::Value *)jarg1;
15898   {
15899     try {
15900       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15901     } catch (std::out_of_range& e) {
15902       {
15903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15904       };
15905     } catch (std::exception& e) {
15906       {
15907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15908       };
15909     } catch (...) {
15910       {
15911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15912       };
15913     }
15914   }
15915   jresult = (void *)result;
15916   return jresult;
15917 }
15918
15919
15920 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15921   char * jresult ;
15922   Dali::Property::Type arg1 ;
15923   char *result = 0 ;
15924
15925   arg1 = (Dali::Property::Type)jarg1;
15926   {
15927     try {
15928       result = (char *)Dali::PropertyTypes::GetName(arg1);
15929     } catch (std::out_of_range& e) {
15930       {
15931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15932       };
15933     } catch (std::exception& e) {
15934       {
15935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15936       };
15937     } catch (...) {
15938       {
15939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15940       };
15941     }
15942   }
15943   jresult = SWIG_csharp_string_callback((const char *)result);
15944   return jresult;
15945 }
15946
15947
15948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15949   unsigned int jresult ;
15950   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15951   std::string *arg2 = 0 ;
15952   Dali::Property::Map *arg3 = 0 ;
15953   bool result;
15954
15955   arg1 = (Dali::BaseObject *)jarg1;
15956   if (!jarg2) {
15957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15958     return 0;
15959   }
15960   std::string arg2_str(jarg2);
15961   arg2 = &arg2_str;
15962   arg3 = (Dali::Property::Map *)jarg3;
15963   if (!arg3) {
15964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15965     return 0;
15966   }
15967   {
15968     try {
15969       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15970     } catch (std::out_of_range& e) {
15971       {
15972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15973       };
15974     } catch (std::exception& e) {
15975       {
15976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15977       };
15978     } catch (...) {
15979       {
15980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15981       };
15982     }
15983   }
15984   jresult = result;
15985
15986   //argout typemap for const std::string&
15987
15988   return jresult;
15989 }
15990
15991
15992 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15993   char * jresult ;
15994   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15995   std::string *result = 0 ;
15996
15997   arg1 = (Dali::BaseObject *)jarg1;
15998   {
15999     try {
16000       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16001     } catch (std::out_of_range& e) {
16002       {
16003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16004       };
16005     } catch (std::exception& e) {
16006       {
16007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16008       };
16009     } catch (...) {
16010       {
16011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16012       };
16013     }
16014   }
16015   jresult = SWIG_csharp_string_callback(result->c_str());
16016   return jresult;
16017 }
16018
16019
16020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16021   unsigned int jresult ;
16022   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16023   Dali::TypeInfo *arg2 = 0 ;
16024   bool result;
16025
16026   arg1 = (Dali::BaseObject *)jarg1;
16027   arg2 = (Dali::TypeInfo *)jarg2;
16028   if (!arg2) {
16029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16030     return 0;
16031   }
16032   {
16033     try {
16034       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*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 (...) {
16044       {
16045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16046       };
16047     }
16048   }
16049   jresult = result;
16050   return jresult;
16051 }
16052
16053
16054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16055   unsigned int jresult ;
16056   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16057   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16058   std::string *arg3 = 0 ;
16059   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16060   bool result;
16061
16062   arg1 = (Dali::BaseObject *)jarg1;
16063   arg2 = (ConnectionTrackerInterface *)jarg2;
16064   if (!jarg3) {
16065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16066     return 0;
16067   }
16068   std::string arg3_str(jarg3);
16069   arg3 = &arg3_str;
16070   arg4 = (FunctorDelegate *)jarg4;
16071   {
16072     try {
16073       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16074     } catch (std::out_of_range& e) {
16075       {
16076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16077       };
16078     } catch (std::exception& e) {
16079       {
16080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16081       };
16082     } catch (...) {
16083       {
16084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16085       };
16086     }
16087   }
16088   jresult = result;
16089
16090   //argout typemap for const std::string&
16091
16092   return jresult;
16093 }
16094
16095
16096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16097   void * jresult ;
16098   Dali::BaseHandle *arg1 = 0 ;
16099   Dali::BaseObject *result = 0 ;
16100
16101   arg1 = (Dali::BaseHandle *)jarg1;
16102   if (!arg1) {
16103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16104     return 0;
16105   }
16106   {
16107     try {
16108       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16109     } catch (std::out_of_range& e) {
16110       {
16111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (std::exception& e) {
16114       {
16115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123   jresult = (void *)result;
16124   return jresult;
16125 }
16126
16127
16128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16129   void * jresult ;
16130   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16131   Dali::BaseHandle *result = 0 ;
16132
16133   arg1 = (Dali::BaseObject *)jarg1;
16134   {
16135     try {
16136       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (...) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16148       };
16149     }
16150   }
16151   jresult = (void *)result;
16152   return jresult;
16153 }
16154
16155
16156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16157   void * jresult ;
16158   Dali::BaseHandle *result = 0 ;
16159
16160   {
16161     try {
16162       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16163     } catch (std::out_of_range& e) {
16164       {
16165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (std::exception& e) {
16168       {
16169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (...) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16174       };
16175     }
16176   }
16177   jresult = (void *)result;
16178   return jresult;
16179 }
16180
16181
16182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16183   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16184
16185   arg1 = (Dali::BaseHandle *)jarg1;
16186   {
16187     try {
16188       delete arg1;
16189     } catch (std::out_of_range& e) {
16190       {
16191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16192       };
16193     } catch (std::exception& e) {
16194       {
16195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16196       };
16197     } catch (...) {
16198       {
16199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16200       };
16201     }
16202   }
16203 }
16204
16205
16206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16207   void * jresult ;
16208   Dali::BaseHandle *arg1 = 0 ;
16209   Dali::BaseHandle *result = 0 ;
16210
16211   arg1 = (Dali::BaseHandle *)jarg1;
16212   if (!arg1) {
16213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16214     return 0;
16215   }
16216   {
16217     try {
16218       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16219     } catch (std::out_of_range& e) {
16220       {
16221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16222       };
16223     } catch (std::exception& e) {
16224       {
16225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16226       };
16227     } catch (...) {
16228       {
16229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16230       };
16231     }
16232   }
16233   jresult = (void *)result;
16234   return jresult;
16235 }
16236
16237
16238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16239   void * jresult ;
16240   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16241   Dali::BaseHandle *arg2 = 0 ;
16242   Dali::BaseHandle *result = 0 ;
16243
16244   arg1 = (Dali::BaseHandle *)jarg1;
16245   arg2 = (Dali::BaseHandle *)jarg2;
16246   if (!arg2) {
16247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16248     return 0;
16249   }
16250   {
16251     try {
16252       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16253     } catch (std::out_of_range& e) {
16254       {
16255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16256       };
16257     } catch (std::exception& e) {
16258       {
16259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16260       };
16261     } catch (...) {
16262       {
16263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16264       };
16265     }
16266   }
16267   jresult = (void *)result;
16268   return jresult;
16269 }
16270
16271
16272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16273   unsigned int jresult ;
16274   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16275   std::string *arg2 = 0 ;
16276   Dali::Property::Map *arg3 = 0 ;
16277   bool result;
16278
16279   arg1 = (Dali::BaseHandle *)jarg1;
16280   if (!jarg2) {
16281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16282     return 0;
16283   }
16284   std::string arg2_str(jarg2);
16285   arg2 = &arg2_str;
16286   arg3 = (Dali::Property::Map *)jarg3;
16287   if (!arg3) {
16288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16289     return 0;
16290   }
16291   {
16292     try {
16293       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16294     } catch (std::out_of_range& e) {
16295       {
16296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16297       };
16298     } catch (std::exception& e) {
16299       {
16300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16301       };
16302     } catch (...) {
16303       {
16304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16305       };
16306     }
16307   }
16308   jresult = result;
16309
16310   //argout typemap for const std::string&
16311
16312   return jresult;
16313 }
16314
16315
16316 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16317   char * jresult ;
16318   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16319   std::string *result = 0 ;
16320
16321   arg1 = (Dali::BaseHandle *)jarg1;
16322   {
16323     try {
16324       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16325     } catch (std::out_of_range& e) {
16326       {
16327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16328       };
16329     } catch (std::exception& e) {
16330       {
16331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16332       };
16333     } catch (...) {
16334       {
16335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16336       };
16337     }
16338   }
16339   jresult = SWIG_csharp_string_callback(result->c_str());
16340   return jresult;
16341 }
16342
16343
16344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16345   unsigned int jresult ;
16346   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16347   Dali::TypeInfo *arg2 = 0 ;
16348   bool result;
16349
16350   arg1 = (Dali::BaseHandle *)jarg1;
16351   arg2 = (Dali::TypeInfo *)jarg2;
16352   if (!arg2) {
16353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16354     return 0;
16355   }
16356   {
16357     try {
16358       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16359     } catch (std::out_of_range& e) {
16360       {
16361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (std::exception& e) {
16364       {
16365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373   jresult = result;
16374   return jresult;
16375 }
16376
16377
16378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16379   void * jresult ;
16380   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16381   Dali::BaseObject *result = 0 ;
16382
16383   arg1 = (Dali::BaseHandle *)jarg1;
16384   {
16385     try {
16386       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16387     } catch (std::out_of_range& e) {
16388       {
16389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16390       };
16391     } catch (std::exception& e) {
16392       {
16393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16394       };
16395     } catch (...) {
16396       {
16397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16398       };
16399     }
16400   }
16401   jresult = (void *)result;
16402   return jresult;
16403 }
16404
16405
16406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16407   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16408
16409   arg1 = (Dali::BaseHandle *)jarg1;
16410   {
16411     try {
16412       (arg1)->Reset();
16413     } catch (std::out_of_range& e) {
16414       {
16415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16416       };
16417     } catch (std::exception& e) {
16418       {
16419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16420       };
16421     } catch (...) {
16422       {
16423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16424       };
16425     }
16426   }
16427 }
16428
16429
16430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16431   unsigned int jresult ;
16432   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16433   Dali::BaseHandle *arg2 = 0 ;
16434   bool result;
16435
16436   arg1 = (Dali::BaseHandle *)jarg1;
16437   arg2 = (Dali::BaseHandle *)jarg2;
16438   if (!arg2) {
16439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16440     return 0;
16441   }
16442   {
16443     try {
16444       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16445     } catch (std::out_of_range& e) {
16446       {
16447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16448       };
16449     } catch (std::exception& e) {
16450       {
16451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16452       };
16453     } catch (...) {
16454       {
16455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16456       };
16457     }
16458   }
16459   jresult = result;
16460   return jresult;
16461 }
16462
16463
16464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16465   unsigned int jresult ;
16466   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16467   Dali::BaseHandle *arg2 = 0 ;
16468   bool result;
16469
16470   arg1 = (Dali::BaseHandle *)jarg1;
16471   arg2 = (Dali::BaseHandle *)jarg2;
16472   if (!arg2) {
16473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16474     return 0;
16475   }
16476   {
16477     try {
16478       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16479     } catch (std::out_of_range& e) {
16480       {
16481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16482       };
16483     } catch (std::exception& e) {
16484       {
16485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16486       };
16487     } catch (...) {
16488       {
16489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16490       };
16491     }
16492   }
16493   jresult = result;
16494   return jresult;
16495 }
16496
16497
16498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16499   void * jresult ;
16500   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16501   Dali::RefObject *result = 0 ;
16502
16503   arg1 = (Dali::BaseHandle *)jarg1;
16504   {
16505     try {
16506       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16507     } catch (std::out_of_range& e) {
16508       {
16509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16510       };
16511     } catch (std::exception& e) {
16512       {
16513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16514       };
16515     } catch (...) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16518       };
16519     }
16520   }
16521   jresult = (void *)result;
16522   return jresult;
16523 }
16524
16525
16526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16527   unsigned int jresult ;
16528   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16529   bool result;
16530
16531   arg1 = (Dali::BaseHandle *)jarg1;
16532   {
16533     try {
16534       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16535     } catch (std::out_of_range& e) {
16536       {
16537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16538       };
16539     } catch (std::exception& e) {
16540       {
16541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16542       };
16543     } catch (...) {
16544       {
16545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16546       };
16547     }
16548   }
16549   jresult = result;
16550   return jresult;
16551 }
16552
16553
16554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16555   unsigned int jresult ;
16556   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16557   Dali::BaseHandle *arg2 = 0 ;
16558   bool result;
16559
16560   arg1 = (Dali::BaseHandle *)jarg1;
16561   arg2 = (Dali::BaseHandle *)jarg2;
16562   if (!arg2) {
16563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16564     return 0;
16565   }
16566   {
16567     try {
16568       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16569     } catch (std::out_of_range& e) {
16570       {
16571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16572       };
16573     } catch (std::exception& e) {
16574       {
16575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16576       };
16577     } catch (...) {
16578       {
16579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16580       };
16581     }
16582   }
16583   jresult = result;
16584   return jresult;
16585 }
16586
16587
16588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16589   unsigned int jresult ;
16590   Dali::BaseHandle *arg1 = 0 ;
16591   Dali::BaseHandle *arg2 = 0 ;
16592   bool result;
16593
16594   arg1 = (Dali::BaseHandle *)jarg1;
16595   if (!arg1) {
16596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16597     return 0;
16598   }
16599   arg2 = (Dali::BaseHandle *)jarg2;
16600   if (!arg2) {
16601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16602     return 0;
16603   }
16604   {
16605     try {
16606       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16607     } catch (std::out_of_range& e) {
16608       {
16609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16610       };
16611     } catch (std::exception& e) {
16612       {
16613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16614       };
16615     } catch (...) {
16616       {
16617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16618       };
16619     }
16620   }
16621   jresult = result;
16622   return jresult;
16623 }
16624
16625
16626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16627   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16628
16629   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16630   {
16631     try {
16632       delete arg1;
16633     } catch (std::out_of_range& e) {
16634       {
16635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16636       };
16637     } catch (std::exception& e) {
16638       {
16639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16640       };
16641     } catch (...) {
16642       {
16643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16644       };
16645     }
16646   }
16647 }
16648
16649
16650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16651   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16652   SlotObserver *arg2 = (SlotObserver *) 0 ;
16653   CallbackBase *arg3 = (CallbackBase *) 0 ;
16654
16655   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16656   arg2 = (SlotObserver *)jarg2;
16657   arg3 = (CallbackBase *)jarg3;
16658   {
16659     try {
16660       (arg1)->SignalConnected(arg2,arg3);
16661     } catch (std::out_of_range& e) {
16662       {
16663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16664       };
16665     } catch (std::exception& e) {
16666       {
16667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16668       };
16669     } catch (...) {
16670       {
16671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16672       };
16673     }
16674   }
16675 }
16676
16677
16678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16679   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16680
16681   arg1 = (Dali::SignalObserver *)jarg1;
16682   {
16683     try {
16684       delete arg1;
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16692       };
16693     } catch (...) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16696       };
16697     }
16698   }
16699 }
16700
16701
16702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16703   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16704   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16705   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16706
16707   arg1 = (Dali::SignalObserver *)jarg1;
16708   arg2 = (Dali::SlotObserver *)jarg2;
16709   arg3 = (Dali::CallbackBase *)jarg3;
16710   {
16711     try {
16712       (arg1)->SignalDisconnected(arg2,arg3);
16713     } catch (std::out_of_range& e) {
16714       {
16715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16716       };
16717     } catch (std::exception& e) {
16718       {
16719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16720       };
16721     } catch (...) {
16722       {
16723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16724       };
16725     }
16726   }
16727 }
16728
16729
16730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16731   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16732
16733   arg1 = (Dali::SlotObserver *)jarg1;
16734   {
16735     try {
16736       delete arg1;
16737     } catch (std::out_of_range& e) {
16738       {
16739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16740       };
16741     } catch (std::exception& e) {
16742       {
16743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16744       };
16745     } catch (...) {
16746       {
16747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16748       };
16749     }
16750   }
16751 }
16752
16753
16754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16755   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16756   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16757
16758   arg1 = (Dali::SlotObserver *)jarg1;
16759   arg2 = (Dali::CallbackBase *)jarg2;
16760   {
16761     try {
16762       (arg1)->SlotDisconnected(arg2);
16763     } catch (std::out_of_range& e) {
16764       {
16765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16766       };
16767     } catch (std::exception& e) {
16768       {
16769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16770       };
16771     } catch (...) {
16772       {
16773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16774       };
16775     }
16776   }
16777 }
16778
16779
16780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16781   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16782
16783   arg1 = (Dali::ConnectionTracker *)jarg1;
16784   {
16785     try {
16786       delete arg1;
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16794       };
16795     } catch (...) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16798       };
16799     }
16800   }
16801 }
16802
16803
16804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16805   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16806
16807   arg1 = (Dali::ConnectionTracker *)jarg1;
16808   {
16809     try {
16810       (arg1)->DisconnectAll();
16811     } catch (std::out_of_range& e) {
16812       {
16813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16814       };
16815     } catch (std::exception& e) {
16816       {
16817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16822       };
16823     }
16824   }
16825 }
16826
16827
16828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16829   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16830   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16831   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16832
16833   arg1 = (Dali::ConnectionTracker *)jarg1;
16834   arg2 = (Dali::SlotObserver *)jarg2;
16835   arg3 = (Dali::CallbackBase *)jarg3;
16836   {
16837     try {
16838       (arg1)->SignalConnected(arg2,arg3);
16839     } catch (std::out_of_range& e) {
16840       {
16841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16842       };
16843     } catch (std::exception& e) {
16844       {
16845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16846       };
16847     } catch (...) {
16848       {
16849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16850       };
16851     }
16852   }
16853 }
16854
16855
16856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16857   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16858   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16859   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16860
16861   arg1 = (Dali::ConnectionTracker *)jarg1;
16862   arg2 = (Dali::SlotObserver *)jarg2;
16863   arg3 = (Dali::CallbackBase *)jarg3;
16864   {
16865     try {
16866       (arg1)->SignalDisconnected(arg2,arg3);
16867     } catch (std::out_of_range& e) {
16868       {
16869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16870       };
16871     } catch (std::exception& e) {
16872       {
16873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16874       };
16875     } catch (...) {
16876       {
16877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16878       };
16879     }
16880   }
16881 }
16882
16883
16884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16885   unsigned long jresult ;
16886   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16887   std::size_t result;
16888
16889   arg1 = (Dali::ConnectionTracker *)jarg1;
16890   {
16891     try {
16892       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16893     } catch (std::out_of_range& e) {
16894       {
16895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16896       };
16897     } catch (std::exception& e) {
16898       {
16899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (...) {
16902       {
16903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16904       };
16905     }
16906   }
16907   jresult = (unsigned long)result;
16908   return jresult;
16909 }
16910
16911
16912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16913   void * jresult ;
16914   Dali::ObjectRegistry *result = 0 ;
16915
16916   {
16917     try {
16918       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16919     } catch (std::out_of_range& e) {
16920       {
16921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16922       };
16923     } catch (std::exception& e) {
16924       {
16925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16926       };
16927     } catch (...) {
16928       {
16929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16930       };
16931     }
16932   }
16933   jresult = (void *)result;
16934   return jresult;
16935 }
16936
16937
16938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16939   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16940
16941   arg1 = (Dali::ObjectRegistry *)jarg1;
16942   {
16943     try {
16944       delete arg1;
16945     } catch (std::out_of_range& e) {
16946       {
16947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16948       };
16949     } catch (std::exception& e) {
16950       {
16951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16952       };
16953     } catch (...) {
16954       {
16955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16956       };
16957     }
16958   }
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16963   void * jresult ;
16964   Dali::ObjectRegistry *arg1 = 0 ;
16965   Dali::ObjectRegistry *result = 0 ;
16966
16967   arg1 = (Dali::ObjectRegistry *)jarg1;
16968   if (!arg1) {
16969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16970     return 0;
16971   }
16972   {
16973     try {
16974       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16975     } catch (std::out_of_range& e) {
16976       {
16977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (std::exception& e) {
16980       {
16981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16982       };
16983     } catch (...) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16986       };
16987     }
16988   }
16989   jresult = (void *)result;
16990   return jresult;
16991 }
16992
16993
16994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16995   void * jresult ;
16996   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16997   Dali::ObjectRegistry *arg2 = 0 ;
16998   Dali::ObjectRegistry *result = 0 ;
16999
17000   arg1 = (Dali::ObjectRegistry *)jarg1;
17001   arg2 = (Dali::ObjectRegistry *)jarg2;
17002   if (!arg2) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (...) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17020       };
17021     }
17022   }
17023   jresult = (void *)result;
17024   return jresult;
17025 }
17026
17027
17028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17029   void * jresult ;
17030   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17031   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17032
17033   arg1 = (Dali::ObjectRegistry *)jarg1;
17034   {
17035     try {
17036       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17037     } catch (std::out_of_range& e) {
17038       {
17039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17040       };
17041     } catch (std::exception& e) {
17042       {
17043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17044       };
17045     } catch (...) {
17046       {
17047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17048       };
17049     }
17050   }
17051   jresult = (void *)result;
17052   return jresult;
17053 }
17054
17055
17056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17057   void * jresult ;
17058   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17059   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17060
17061   arg1 = (Dali::ObjectRegistry *)jarg1;
17062   {
17063     try {
17064       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17065     } catch (std::out_of_range& e) {
17066       {
17067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17068       };
17069     } catch (std::exception& e) {
17070       {
17071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (...) {
17074       {
17075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17076       };
17077     }
17078   }
17079   jresult = (void *)result;
17080   return jresult;
17081 }
17082
17083
17084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17085   void * jresult ;
17086   Dali::PropertyCondition *result = 0 ;
17087
17088   {
17089     try {
17090       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17091     } catch (std::out_of_range& e) {
17092       {
17093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (std::exception& e) {
17096       {
17097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105   jresult = (void *)result;
17106   return jresult;
17107 }
17108
17109
17110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17111   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17112
17113   arg1 = (Dali::PropertyCondition *)jarg1;
17114   {
17115     try {
17116       delete arg1;
17117     } catch (std::out_of_range& e) {
17118       {
17119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17120       };
17121     } catch (std::exception& e) {
17122       {
17123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17124       };
17125     } catch (...) {
17126       {
17127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17128       };
17129     }
17130   }
17131 }
17132
17133
17134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17135   void * jresult ;
17136   Dali::PropertyCondition *arg1 = 0 ;
17137   Dali::PropertyCondition *result = 0 ;
17138
17139   arg1 = (Dali::PropertyCondition *)jarg1;
17140   if (!arg1) {
17141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17142     return 0;
17143   }
17144   {
17145     try {
17146       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17147     } catch (std::out_of_range& e) {
17148       {
17149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17150       };
17151     } catch (std::exception& e) {
17152       {
17153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17154       };
17155     } catch (...) {
17156       {
17157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17158       };
17159     }
17160   }
17161   jresult = (void *)result;
17162   return jresult;
17163 }
17164
17165
17166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17167   void * jresult ;
17168   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17169   Dali::PropertyCondition *arg2 = 0 ;
17170   Dali::PropertyCondition *result = 0 ;
17171
17172   arg1 = (Dali::PropertyCondition *)jarg1;
17173   arg2 = (Dali::PropertyCondition *)jarg2;
17174   if (!arg2) {
17175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17176     return 0;
17177   }
17178   {
17179     try {
17180       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17181     } catch (std::out_of_range& e) {
17182       {
17183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17184       };
17185     } catch (std::exception& e) {
17186       {
17187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (...) {
17190       {
17191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17192       };
17193     }
17194   }
17195   jresult = (void *)result;
17196   return jresult;
17197 }
17198
17199
17200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17201   unsigned long jresult ;
17202   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17203   std::size_t result;
17204
17205   arg1 = (Dali::PropertyCondition *)jarg1;
17206   {
17207     try {
17208       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17209     } catch (std::out_of_range& e) {
17210       {
17211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17212       };
17213     } catch (std::exception& e) {
17214       {
17215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17216       };
17217     } catch (...) {
17218       {
17219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17220       };
17221     }
17222   }
17223   jresult = (unsigned long)result;
17224   return jresult;
17225 }
17226
17227
17228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17229   float jresult ;
17230   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17231   std::size_t arg2 ;
17232   float result;
17233
17234   arg1 = (Dali::PropertyCondition *)jarg1;
17235   arg2 = (std::size_t)jarg2;
17236   {
17237     try {
17238       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17239     } catch (std::out_of_range& e) {
17240       {
17241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17242       };
17243     } catch (std::exception& e) {
17244       {
17245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17246       };
17247     } catch (...) {
17248       {
17249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17250       };
17251     }
17252   }
17253   jresult = result;
17254   return jresult;
17255 }
17256
17257
17258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17259   void * jresult ;
17260   float arg1 ;
17261   Dali::PropertyCondition result;
17262
17263   arg1 = (float)jarg1;
17264   {
17265     try {
17266       result = Dali::LessThanCondition(arg1);
17267     } catch (std::out_of_range& e) {
17268       {
17269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (std::exception& e) {
17272       {
17273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17282   return jresult;
17283 }
17284
17285
17286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17287   void * jresult ;
17288   float arg1 ;
17289   Dali::PropertyCondition result;
17290
17291   arg1 = (float)jarg1;
17292   {
17293     try {
17294       result = Dali::GreaterThanCondition(arg1);
17295     } catch (std::out_of_range& e) {
17296       {
17297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17298       };
17299     } catch (std::exception& e) {
17300       {
17301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17302       };
17303     } catch (...) {
17304       {
17305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17306       };
17307     }
17308   }
17309   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17310   return jresult;
17311 }
17312
17313
17314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17315   void * jresult ;
17316   float arg1 ;
17317   float arg2 ;
17318   Dali::PropertyCondition result;
17319
17320   arg1 = (float)jarg1;
17321   arg2 = (float)jarg2;
17322   {
17323     try {
17324       result = Dali::InsideCondition(arg1,arg2);
17325     } catch (std::out_of_range& e) {
17326       {
17327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17328       };
17329     } catch (std::exception& e) {
17330       {
17331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17332       };
17333     } catch (...) {
17334       {
17335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17336       };
17337     }
17338   }
17339   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17340   return jresult;
17341 }
17342
17343
17344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17345   void * jresult ;
17346   float arg1 ;
17347   float arg2 ;
17348   Dali::PropertyCondition result;
17349
17350   arg1 = (float)jarg1;
17351   arg2 = (float)jarg2;
17352   {
17353     try {
17354       result = Dali::OutsideCondition(arg1,arg2);
17355     } catch (std::out_of_range& e) {
17356       {
17357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17358       };
17359     } catch (std::exception& e) {
17360       {
17361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17362       };
17363     } catch (...) {
17364       {
17365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17366       };
17367     }
17368   }
17369   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17370   return jresult;
17371 }
17372
17373
17374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17375   void * jresult ;
17376   float arg1 ;
17377   float arg2 ;
17378   Dali::PropertyCondition result;
17379
17380   arg1 = (float)jarg1;
17381   arg2 = (float)jarg2;
17382   {
17383     try {
17384       result = Dali::StepCondition(arg1,arg2);
17385     } catch (std::out_of_range& e) {
17386       {
17387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17388       };
17389     } catch (std::exception& e) {
17390       {
17391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17392       };
17393     } catch (...) {
17394       {
17395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17396       };
17397     }
17398   }
17399   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17400   return jresult;
17401 }
17402
17403
17404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17405   void * jresult ;
17406   float arg1 ;
17407   Dali::PropertyCondition result;
17408
17409   arg1 = (float)jarg1;
17410   {
17411     try {
17412       result = Dali::StepCondition(arg1);
17413     } catch (std::out_of_range& e) {
17414       {
17415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17416       };
17417     } catch (std::exception& e) {
17418       {
17419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17420       };
17421     } catch (...) {
17422       {
17423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17424       };
17425     }
17426   }
17427   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17428   return jresult;
17429 }
17430
17431
17432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17433   void * jresult ;
17434   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17435   Dali::PropertyCondition result;
17436
17437   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17438   if (!arg1) {
17439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17440     return 0;
17441   }
17442   {
17443     try {
17444       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17445     } catch (std::out_of_range& e) {
17446       {
17447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17448       };
17449     } catch (std::exception& e) {
17450       {
17451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17452       };
17453     } catch (...) {
17454       {
17455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17456       };
17457     }
17458   }
17459   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17460   return jresult;
17461 }
17462
17463
17464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17465   void * jresult ;
17466   Dali::PropertyNotification *result = 0 ;
17467
17468   {
17469     try {
17470       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17471     } catch (std::out_of_range& e) {
17472       {
17473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17474       };
17475     } catch (std::exception& e) {
17476       {
17477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17478       };
17479     } catch (...) {
17480       {
17481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17482       };
17483     }
17484   }
17485   jresult = (void *)result;
17486   return jresult;
17487 }
17488
17489
17490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17491   void * jresult ;
17492   Dali::BaseHandle arg1 ;
17493   Dali::BaseHandle *argp1 ;
17494   Dali::PropertyNotification result;
17495
17496   argp1 = (Dali::BaseHandle *)jarg1;
17497   if (!argp1) {
17498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17499     return 0;
17500   }
17501   arg1 = *argp1;
17502   {
17503     try {
17504       result = Dali::PropertyNotification::DownCast(arg1);
17505     } catch (std::out_of_range& e) {
17506       {
17507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17508       };
17509     } catch (std::exception& e) {
17510       {
17511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (...) {
17514       {
17515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17516       };
17517     }
17518   }
17519   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17520   return jresult;
17521 }
17522
17523
17524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17525   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17526
17527   arg1 = (Dali::PropertyNotification *)jarg1;
17528   {
17529     try {
17530       delete arg1;
17531     } catch (std::out_of_range& e) {
17532       {
17533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17534       };
17535     } catch (std::exception& e) {
17536       {
17537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17538       };
17539     } catch (...) {
17540       {
17541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17542       };
17543     }
17544   }
17545 }
17546
17547
17548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17549   void * jresult ;
17550   Dali::PropertyNotification *arg1 = 0 ;
17551   Dali::PropertyNotification *result = 0 ;
17552
17553   arg1 = (Dali::PropertyNotification *)jarg1;
17554   if (!arg1) {
17555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17556     return 0;
17557   }
17558   {
17559     try {
17560       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17561     } catch (std::out_of_range& e) {
17562       {
17563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17564       };
17565     } catch (std::exception& e) {
17566       {
17567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17568       };
17569     } catch (...) {
17570       {
17571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17572       };
17573     }
17574   }
17575   jresult = (void *)result;
17576   return jresult;
17577 }
17578
17579
17580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17581   void * jresult ;
17582   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17583   Dali::PropertyNotification *arg2 = 0 ;
17584   Dali::PropertyNotification *result = 0 ;
17585
17586   arg1 = (Dali::PropertyNotification *)jarg1;
17587   arg2 = (Dali::PropertyNotification *)jarg2;
17588   if (!arg2) {
17589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17590     return 0;
17591   }
17592   {
17593     try {
17594       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17595     } catch (std::out_of_range& e) {
17596       {
17597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17598       };
17599     } catch (std::exception& e) {
17600       {
17601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17602       };
17603     } catch (...) {
17604       {
17605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17606       };
17607     }
17608   }
17609   jresult = (void *)result;
17610   return jresult;
17611 }
17612
17613
17614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17615   void * jresult ;
17616   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17617   Dali::PropertyCondition result;
17618
17619   arg1 = (Dali::PropertyNotification *)jarg1;
17620   {
17621     try {
17622       result = (arg1)->GetCondition();
17623     } catch (std::out_of_range& e) {
17624       {
17625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17626       };
17627     } catch (std::exception& e) {
17628       {
17629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17630       };
17631     } catch (...) {
17632       {
17633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17634       };
17635     }
17636   }
17637   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17638   return jresult;
17639 }
17640
17641
17642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17643   void * jresult ;
17644   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17645   Dali::Handle result;
17646
17647   arg1 = (Dali::PropertyNotification *)jarg1;
17648   {
17649     try {
17650       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17651     } catch (std::out_of_range& e) {
17652       {
17653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17654       };
17655     } catch (std::exception& e) {
17656       {
17657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17658       };
17659     } catch (...) {
17660       {
17661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17662       };
17663     }
17664   }
17665   jresult = new Dali::Handle((const Dali::Handle &)result);
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17671   int jresult ;
17672   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17673   Dali::Property::Index result;
17674
17675   arg1 = (Dali::PropertyNotification *)jarg1;
17676   {
17677     try {
17678       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17679     } catch (std::out_of_range& e) {
17680       {
17681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17682       };
17683     } catch (std::exception& e) {
17684       {
17685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (...) {
17688       {
17689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17690       };
17691     }
17692   }
17693   jresult = result;
17694   return jresult;
17695 }
17696
17697
17698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17699   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17700   Dali::PropertyNotification::NotifyMode arg2 ;
17701
17702   arg1 = (Dali::PropertyNotification *)jarg1;
17703   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17704   {
17705     try {
17706       (arg1)->SetNotifyMode(arg2);
17707     } catch (std::out_of_range& e) {
17708       {
17709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17710       };
17711     } catch (std::exception& e) {
17712       {
17713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17718       };
17719     }
17720   }
17721 }
17722
17723
17724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17725   int jresult ;
17726   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17727   Dali::PropertyNotification::NotifyMode result;
17728
17729   arg1 = (Dali::PropertyNotification *)jarg1;
17730   {
17731     try {
17732       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17733     } catch (std::out_of_range& e) {
17734       {
17735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17736       };
17737     } catch (std::exception& e) {
17738       {
17739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (...) {
17742       {
17743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17744       };
17745     }
17746   }
17747   jresult = (int)result;
17748   return jresult;
17749 }
17750
17751
17752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17753   unsigned int jresult ;
17754   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17755   bool result;
17756
17757   arg1 = (Dali::PropertyNotification *)jarg1;
17758   {
17759     try {
17760       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17761     } catch (std::out_of_range& e) {
17762       {
17763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (std::exception& e) {
17766       {
17767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (...) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17772       };
17773     }
17774   }
17775   jresult = result;
17776   return jresult;
17777 }
17778
17779
17780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17781   void * jresult ;
17782   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17783   Dali::PropertyNotifySignalType *result = 0 ;
17784
17785   arg1 = (Dali::PropertyNotification *)jarg1;
17786   {
17787     try {
17788       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17789     } catch (std::out_of_range& e) {
17790       {
17791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17792       };
17793     } catch (std::exception& e) {
17794       {
17795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17796       };
17797     } catch (...) {
17798       {
17799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17800       };
17801     }
17802   }
17803   jresult = (void *)result;
17804   return jresult;
17805 }
17806
17807
17808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17809   void * jresult ;
17810   Dali::Handle *result = 0 ;
17811
17812   {
17813     try {
17814       result = (Dali::Handle *)new Dali::Handle();
17815     } catch (std::out_of_range& e) {
17816       {
17817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17818       };
17819     } catch (std::exception& e) {
17820       {
17821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (...) {
17824       {
17825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17826       };
17827     }
17828   }
17829   jresult = (void *)result;
17830   return jresult;
17831 }
17832
17833
17834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17835   void * jresult ;
17836   Dali::Handle result;
17837
17838   {
17839     try {
17840       result = Dali::Handle::New();
17841     } catch (std::out_of_range& e) {
17842       {
17843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17844       };
17845     } catch (std::exception& e) {
17846       {
17847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17848       };
17849     } catch (...) {
17850       {
17851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17852       };
17853     }
17854   }
17855   jresult = new Dali::Handle((const Dali::Handle &)result);
17856   return jresult;
17857 }
17858
17859
17860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17861   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17862
17863   arg1 = (Dali::Handle *)jarg1;
17864   {
17865     try {
17866       delete arg1;
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17874       };
17875     } catch (...) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17878       };
17879     }
17880   }
17881 }
17882
17883
17884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17885   void * jresult ;
17886   Dali::Handle *arg1 = 0 ;
17887   Dali::Handle *result = 0 ;
17888
17889   arg1 = (Dali::Handle *)jarg1;
17890   if (!arg1) {
17891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17892     return 0;
17893   }
17894   {
17895     try {
17896       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17897     } catch (std::out_of_range& e) {
17898       {
17899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17900       };
17901     } catch (std::exception& e) {
17902       {
17903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17904       };
17905     } catch (...) {
17906       {
17907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17908       };
17909     }
17910   }
17911   jresult = (void *)result;
17912   return jresult;
17913 }
17914
17915
17916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17917   void * jresult ;
17918   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17919   Dali::Handle *arg2 = 0 ;
17920   Dali::Handle *result = 0 ;
17921
17922   arg1 = (Dali::Handle *)jarg1;
17923   arg2 = (Dali::Handle *)jarg2;
17924   if (!arg2) {
17925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17926     return 0;
17927   }
17928   {
17929     try {
17930       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17931     } catch (std::out_of_range& e) {
17932       {
17933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17934       };
17935     } catch (std::exception& e) {
17936       {
17937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17938       };
17939     } catch (...) {
17940       {
17941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17942       };
17943     }
17944   }
17945   jresult = (void *)result;
17946   return jresult;
17947 }
17948
17949
17950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17951   void * jresult ;
17952   Dali::BaseHandle arg1 ;
17953   Dali::BaseHandle *argp1 ;
17954   Dali::Handle result;
17955
17956   argp1 = (Dali::BaseHandle *)jarg1;
17957   if (!argp1) {
17958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17959     return 0;
17960   }
17961   arg1 = *argp1;
17962   {
17963     try {
17964       result = Dali::Handle::DownCast(arg1);
17965     } catch (std::out_of_range& e) {
17966       {
17967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (std::exception& e) {
17970       {
17971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (...) {
17974       {
17975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17976       };
17977     }
17978   }
17979   jresult = new Dali::Handle((const Dali::Handle &)result);
17980   return jresult;
17981 }
17982
17983
17984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17985   unsigned int jresult ;
17986   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17987   Dali::Handle::Capability arg2 ;
17988   bool result;
17989
17990   arg1 = (Dali::Handle *)jarg1;
17991   arg2 = (Dali::Handle::Capability)jarg2;
17992   {
17993     try {
17994       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17995     } catch (std::out_of_range& e) {
17996       {
17997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17998       };
17999     } catch (std::exception& e) {
18000       {
18001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18002       };
18003     } catch (...) {
18004       {
18005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18006       };
18007     }
18008   }
18009   jresult = result;
18010   return jresult;
18011 }
18012
18013
18014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18015   unsigned int jresult ;
18016   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18017   unsigned int result;
18018
18019   arg1 = (Dali::Handle *)jarg1;
18020   {
18021     try {
18022       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18023     } catch (std::out_of_range& e) {
18024       {
18025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18026       };
18027     } catch (std::exception& e) {
18028       {
18029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (...) {
18032       {
18033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18034       };
18035     }
18036   }
18037   jresult = result;
18038   return jresult;
18039 }
18040
18041
18042 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18043   char * jresult ;
18044   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18045   Dali::Property::Index arg2 ;
18046   std::string result;
18047
18048   arg1 = (Dali::Handle *)jarg1;
18049   arg2 = (Dali::Property::Index)jarg2;
18050   {
18051     try {
18052       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18053     } catch (std::out_of_range& e) {
18054       {
18055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18056       };
18057     } catch (std::exception& e) {
18058       {
18059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (...) {
18062       {
18063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18064       };
18065     }
18066   }
18067   jresult = SWIG_csharp_string_callback((&result)->c_str());
18068   return jresult;
18069 }
18070
18071
18072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18073   int jresult ;
18074   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18075   std::string *arg2 = 0 ;
18076   Dali::Property::Index result;
18077
18078   arg1 = (Dali::Handle *)jarg1;
18079   if (!jarg2) {
18080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18081     return 0;
18082   }
18083   std::string arg2_str(jarg2);
18084   arg2 = &arg2_str;
18085   {
18086     try {
18087       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18088     } catch (std::out_of_range& e) {
18089       {
18090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18091       };
18092     } catch (std::exception& e) {
18093       {
18094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18095       };
18096     } catch (...) {
18097       {
18098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18099       };
18100     }
18101   }
18102   jresult = result;
18103
18104   //argout typemap for const std::string&
18105
18106   return jresult;
18107 }
18108
18109
18110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18111   unsigned int jresult ;
18112   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18113   Dali::Property::Index arg2 ;
18114   bool result;
18115
18116   arg1 = (Dali::Handle *)jarg1;
18117   arg2 = (Dali::Property::Index)jarg2;
18118   {
18119     try {
18120       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18121     } catch (std::out_of_range& e) {
18122       {
18123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (std::exception& e) {
18126       {
18127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18128       };
18129     } catch (...) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18132       };
18133     }
18134   }
18135   jresult = result;
18136   return jresult;
18137 }
18138
18139
18140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18141   unsigned int jresult ;
18142   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18143   Dali::Property::Index arg2 ;
18144   bool result;
18145
18146   arg1 = (Dali::Handle *)jarg1;
18147   arg2 = (Dali::Property::Index)jarg2;
18148   {
18149     try {
18150       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18151     } catch (std::out_of_range& e) {
18152       {
18153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18154       };
18155     } catch (std::exception& e) {
18156       {
18157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (...) {
18160       {
18161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18162       };
18163     }
18164   }
18165   jresult = result;
18166   return jresult;
18167 }
18168
18169
18170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18171   unsigned int jresult ;
18172   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18173   Dali::Property::Index arg2 ;
18174   bool result;
18175
18176   arg1 = (Dali::Handle *)jarg1;
18177   arg2 = (Dali::Property::Index)jarg2;
18178   {
18179     try {
18180       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18181     } catch (std::out_of_range& e) {
18182       {
18183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18184       };
18185     } catch (std::exception& e) {
18186       {
18187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18188       };
18189     } catch (...) {
18190       {
18191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18192       };
18193     }
18194   }
18195   jresult = result;
18196   return jresult;
18197 }
18198
18199
18200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18201   int jresult ;
18202   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18203   Dali::Property::Index arg2 ;
18204   Dali::Property::Type result;
18205
18206   arg1 = (Dali::Handle *)jarg1;
18207   arg2 = (Dali::Property::Index)jarg2;
18208   {
18209     try {
18210       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18211     } catch (std::out_of_range& e) {
18212       {
18213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18214       };
18215     } catch (std::exception& e) {
18216       {
18217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18218       };
18219     } catch (...) {
18220       {
18221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18222       };
18223     }
18224   }
18225   jresult = (int)result;
18226   return jresult;
18227 }
18228
18229
18230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18231   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18232   Dali::Property::Index arg2 ;
18233   Dali::Property::Value *arg3 = 0 ;
18234
18235   arg1 = (Dali::Handle *)jarg1;
18236   arg2 = (Dali::Property::Index)jarg2;
18237   arg3 = (Dali::Property::Value *)jarg3;
18238   if (!arg3) {
18239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18240     return ;
18241   }
18242   {
18243     try {
18244       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18245     } catch (std::out_of_range& e) {
18246       {
18247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18248       };
18249     } catch (std::exception& e) {
18250       {
18251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18252       };
18253     } catch (...) {
18254       {
18255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18256       };
18257     }
18258   }
18259 }
18260
18261
18262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18263   int jresult ;
18264   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18265   std::string *arg2 = 0 ;
18266   Dali::Property::Value *arg3 = 0 ;
18267   Dali::Property::Index result;
18268
18269   arg1 = (Dali::Handle *)jarg1;
18270   if (!jarg2) {
18271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18272     return 0;
18273   }
18274   std::string arg2_str(jarg2);
18275   arg2 = &arg2_str;
18276   arg3 = (Dali::Property::Value *)jarg3;
18277   if (!arg3) {
18278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18279     return 0;
18280   }
18281   {
18282     try {
18283       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18284     } catch (std::out_of_range& e) {
18285       {
18286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18287       };
18288     } catch (std::exception& e) {
18289       {
18290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18291       };
18292     } catch (...) {
18293       {
18294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18295       };
18296     }
18297   }
18298   jresult = result;
18299
18300   //argout typemap for const std::string&
18301
18302   return jresult;
18303 }
18304
18305
18306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18307   int jresult ;
18308   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18309   std::string *arg2 = 0 ;
18310   Dali::Property::Value *arg3 = 0 ;
18311   Dali::Property::AccessMode arg4 ;
18312   Dali::Property::Index result;
18313
18314   arg1 = (Dali::Handle *)jarg1;
18315   if (!jarg2) {
18316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18317     return 0;
18318   }
18319   std::string arg2_str(jarg2);
18320   arg2 = &arg2_str;
18321   arg3 = (Dali::Property::Value *)jarg3;
18322   if (!arg3) {
18323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18324     return 0;
18325   }
18326   arg4 = (Dali::Property::AccessMode)jarg4;
18327   {
18328     try {
18329       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18330     } catch (std::out_of_range& e) {
18331       {
18332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18333       };
18334     } catch (std::exception& e) {
18335       {
18336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18337       };
18338     } catch (...) {
18339       {
18340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18341       };
18342     }
18343   }
18344   jresult = result;
18345
18346   //argout typemap for const std::string&
18347
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18353   void * jresult ;
18354   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18355   Dali::Property::Index arg2 ;
18356   Dali::Property::Value result;
18357
18358   arg1 = (Dali::Handle *)jarg1;
18359   arg2 = (Dali::Property::Index)jarg2;
18360   {
18361     try {
18362       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18363     } catch (std::out_of_range& e) {
18364       {
18365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18366       };
18367     } catch (std::exception& e) {
18368       {
18369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18370       };
18371     } catch (...) {
18372       {
18373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18374       };
18375     }
18376   }
18377   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18378   return jresult;
18379 }
18380
18381
18382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18383   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18384   Dali::Property::IndexContainer *arg2 = 0 ;
18385
18386   arg1 = (Dali::Handle *)jarg1;
18387   arg2 = (Dali::Property::IndexContainer *)jarg2;
18388   if (!arg2) {
18389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18390     return ;
18391   }
18392   {
18393     try {
18394       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18395     } catch (std::out_of_range& e) {
18396       {
18397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18398       };
18399     } catch (std::exception& e) {
18400       {
18401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18402       };
18403     } catch (...) {
18404       {
18405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18406       };
18407     }
18408   }
18409 }
18410
18411
18412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18413   void * jresult ;
18414   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18415   Dali::Property::Index arg2 ;
18416   Dali::PropertyCondition *arg3 = 0 ;
18417   Dali::PropertyNotification result;
18418
18419   arg1 = (Dali::Handle *)jarg1;
18420   arg2 = (Dali::Property::Index)jarg2;
18421   arg3 = (Dali::PropertyCondition *)jarg3;
18422   if (!arg3) {
18423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18424     return 0;
18425   }
18426   {
18427     try {
18428       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18429     } catch (std::out_of_range& e) {
18430       {
18431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18432       };
18433     } catch (std::exception& e) {
18434       {
18435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18436       };
18437     } catch (...) {
18438       {
18439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18440       };
18441     }
18442   }
18443   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18444   return jresult;
18445 }
18446
18447
18448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18449   void * jresult ;
18450   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18451   Dali::Property::Index arg2 ;
18452   int arg3 ;
18453   Dali::PropertyCondition *arg4 = 0 ;
18454   Dali::PropertyNotification result;
18455
18456   arg1 = (Dali::Handle *)jarg1;
18457   arg2 = (Dali::Property::Index)jarg2;
18458   arg3 = (int)jarg3;
18459   arg4 = (Dali::PropertyCondition *)jarg4;
18460   if (!arg4) {
18461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18462     return 0;
18463   }
18464   {
18465     try {
18466       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18467     } catch (std::out_of_range& e) {
18468       {
18469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18470       };
18471     } catch (std::exception& e) {
18472       {
18473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18474       };
18475     } catch (...) {
18476       {
18477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18478       };
18479     }
18480   }
18481   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18482   return jresult;
18483 }
18484
18485
18486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18487   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18488   Dali::PropertyNotification arg2 ;
18489   Dali::PropertyNotification *argp2 ;
18490
18491   arg1 = (Dali::Handle *)jarg1;
18492   argp2 = (Dali::PropertyNotification *)jarg2;
18493   if (!argp2) {
18494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18495     return ;
18496   }
18497   arg2 = *argp2;
18498   {
18499     try {
18500       (arg1)->RemovePropertyNotification(arg2);
18501     } catch (std::out_of_range& e) {
18502       {
18503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18504       };
18505     } catch (std::exception& e) {
18506       {
18507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18508       };
18509     } catch (...) {
18510       {
18511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18512       };
18513     }
18514   }
18515 }
18516
18517
18518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18519   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18520
18521   arg1 = (Dali::Handle *)jarg1;
18522   {
18523     try {
18524       (arg1)->RemovePropertyNotifications();
18525     } catch (std::out_of_range& e) {
18526       {
18527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18528       };
18529     } catch (std::exception& e) {
18530       {
18531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18532       };
18533     } catch (...) {
18534       {
18535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18536       };
18537     }
18538   }
18539 }
18540
18541
18542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18543   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18544
18545   arg1 = (Dali::Handle *)jarg1;
18546   {
18547     try {
18548       (arg1)->RemoveConstraints();
18549     } catch (std::out_of_range& e) {
18550       {
18551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18552       };
18553     } catch (std::exception& e) {
18554       {
18555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18556       };
18557     } catch (...) {
18558       {
18559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18560       };
18561     }
18562   }
18563 }
18564
18565
18566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18567   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18568   unsigned int arg2 ;
18569
18570   arg1 = (Dali::Handle *)jarg1;
18571   arg2 = (unsigned int)jarg2;
18572   {
18573     try {
18574       (arg1)->RemoveConstraints(arg2);
18575     } catch (std::out_of_range& e) {
18576       {
18577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18578       };
18579     } catch (std::exception& e) {
18580       {
18581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18582       };
18583     } catch (...) {
18584       {
18585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18586       };
18587     }
18588   }
18589 }
18590
18591
18592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18593   int jresult ;
18594   Dali::Property::Index result;
18595
18596   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18597   jresult = result;
18598   return jresult;
18599 }
18600
18601
18602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18603   void * jresult ;
18604   Dali::Handle result;
18605
18606   {
18607     try {
18608       result = Dali::WeightObject::New();
18609     } catch (std::out_of_range& e) {
18610       {
18611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18612       };
18613     } catch (std::exception& e) {
18614       {
18615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18616       };
18617     } catch (...) {
18618       {
18619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18620       };
18621     }
18622   }
18623   jresult = new Dali::Handle((const Dali::Handle &)result);
18624   return jresult;
18625 }
18626
18627
18628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18629   void * jresult ;
18630   Dali::TypeInfo *result = 0 ;
18631
18632   {
18633     try {
18634       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18635     } catch (std::out_of_range& e) {
18636       {
18637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (std::exception& e) {
18640       {
18641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (...) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18646       };
18647     }
18648   }
18649   jresult = (void *)result;
18650   return jresult;
18651 }
18652
18653
18654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18655   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18656
18657   arg1 = (Dali::TypeInfo *)jarg1;
18658   {
18659     try {
18660       delete arg1;
18661     } catch (std::out_of_range& e) {
18662       {
18663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18664       };
18665     } catch (std::exception& e) {
18666       {
18667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18668       };
18669     } catch (...) {
18670       {
18671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18672       };
18673     }
18674   }
18675 }
18676
18677
18678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18679   void * jresult ;
18680   Dali::TypeInfo *arg1 = 0 ;
18681   Dali::TypeInfo *result = 0 ;
18682
18683   arg1 = (Dali::TypeInfo *)jarg1;
18684   if (!arg1) {
18685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18686     return 0;
18687   }
18688   {
18689     try {
18690       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18691     } catch (std::out_of_range& e) {
18692       {
18693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18694       };
18695     } catch (std::exception& e) {
18696       {
18697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18698       };
18699     } catch (...) {
18700       {
18701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18702       };
18703     }
18704   }
18705   jresult = (void *)result;
18706   return jresult;
18707 }
18708
18709
18710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18711   void * jresult ;
18712   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18713   Dali::TypeInfo *arg2 = 0 ;
18714   Dali::TypeInfo *result = 0 ;
18715
18716   arg1 = (Dali::TypeInfo *)jarg1;
18717   arg2 = (Dali::TypeInfo *)jarg2;
18718   if (!arg2) {
18719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18720     return 0;
18721   }
18722   {
18723     try {
18724       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18725     } catch (std::out_of_range& e) {
18726       {
18727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18728       };
18729     } catch (std::exception& e) {
18730       {
18731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (...) {
18734       {
18735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18736       };
18737     }
18738   }
18739   jresult = (void *)result;
18740   return jresult;
18741 }
18742
18743
18744 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18745   char * jresult ;
18746   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18747   std::string *result = 0 ;
18748
18749   arg1 = (Dali::TypeInfo *)jarg1;
18750   {
18751     try {
18752       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18753     } catch (std::out_of_range& e) {
18754       {
18755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18756       };
18757     } catch (std::exception& e) {
18758       {
18759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18760       };
18761     } catch (...) {
18762       {
18763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18764       };
18765     }
18766   }
18767   jresult = SWIG_csharp_string_callback(result->c_str());
18768   return jresult;
18769 }
18770
18771
18772 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18773   char * jresult ;
18774   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18775   std::string *result = 0 ;
18776
18777   arg1 = (Dali::TypeInfo *)jarg1;
18778   {
18779     try {
18780       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18781     } catch (std::out_of_range& e) {
18782       {
18783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (std::exception& e) {
18786       {
18787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795   jresult = SWIG_csharp_string_callback(result->c_str());
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18801   void * jresult ;
18802   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18803   Dali::BaseHandle result;
18804
18805   arg1 = (Dali::TypeInfo *)jarg1;
18806   {
18807     try {
18808       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18809     } catch (std::out_of_range& e) {
18810       {
18811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18812       };
18813     } catch (std::exception& e) {
18814       {
18815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18816       };
18817     } catch (...) {
18818       {
18819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18820       };
18821     }
18822   }
18823   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18824   return jresult;
18825 }
18826
18827
18828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18829   unsigned long jresult ;
18830   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18831   size_t result;
18832
18833   arg1 = (Dali::TypeInfo *)jarg1;
18834   {
18835     try {
18836       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18837     } catch (std::out_of_range& e) {
18838       {
18839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18840       };
18841     } catch (std::exception& e) {
18842       {
18843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18844       };
18845     } catch (...) {
18846       {
18847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18848       };
18849     }
18850   }
18851   jresult = (unsigned long)result;
18852   return jresult;
18853 }
18854
18855
18856 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18857   char * jresult ;
18858   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18859   size_t arg2 ;
18860   std::string result;
18861
18862   arg1 = (Dali::TypeInfo *)jarg1;
18863   arg2 = (size_t)jarg2;
18864   {
18865     try {
18866       result = (arg1)->GetActionName(arg2);
18867     } catch (std::out_of_range& e) {
18868       {
18869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18870       };
18871     } catch (std::exception& e) {
18872       {
18873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18874       };
18875     } catch (...) {
18876       {
18877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18878       };
18879     }
18880   }
18881   jresult = SWIG_csharp_string_callback((&result)->c_str());
18882   return jresult;
18883 }
18884
18885
18886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18887   unsigned long jresult ;
18888   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18889   size_t result;
18890
18891   arg1 = (Dali::TypeInfo *)jarg1;
18892   {
18893     try {
18894       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18895     } catch (std::out_of_range& e) {
18896       {
18897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18898       };
18899     } catch (std::exception& e) {
18900       {
18901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18902       };
18903     } catch (...) {
18904       {
18905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18906       };
18907     }
18908   }
18909   jresult = (unsigned long)result;
18910   return jresult;
18911 }
18912
18913
18914 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18915   char * jresult ;
18916   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18917   size_t arg2 ;
18918   std::string result;
18919
18920   arg1 = (Dali::TypeInfo *)jarg1;
18921   arg2 = (size_t)jarg2;
18922   {
18923     try {
18924       result = (arg1)->GetSignalName(arg2);
18925     } catch (std::out_of_range& e) {
18926       {
18927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18928       };
18929     } catch (std::exception& e) {
18930       {
18931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18932       };
18933     } catch (...) {
18934       {
18935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18936       };
18937     }
18938   }
18939   jresult = SWIG_csharp_string_callback((&result)->c_str());
18940   return jresult;
18941 }
18942
18943
18944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18945   unsigned long jresult ;
18946   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18947   size_t result;
18948
18949   arg1 = (Dali::TypeInfo *)jarg1;
18950   {
18951     try {
18952       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18953     } catch (std::out_of_range& e) {
18954       {
18955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18956       };
18957     } catch (std::exception& e) {
18958       {
18959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18960       };
18961     } catch (...) {
18962       {
18963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18964       };
18965     }
18966   }
18967   jresult = (unsigned long)result;
18968   return jresult;
18969 }
18970
18971
18972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18973   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18974   Dali::Property::IndexContainer *arg2 = 0 ;
18975
18976   arg1 = (Dali::TypeInfo *)jarg1;
18977   arg2 = (Dali::Property::IndexContainer *)jarg2;
18978   if (!arg2) {
18979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18980     return ;
18981   }
18982   {
18983     try {
18984       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18985     } catch (std::out_of_range& e) {
18986       {
18987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18988       };
18989     } catch (std::exception& e) {
18990       {
18991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18992       };
18993     } catch (...) {
18994       {
18995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18996       };
18997     }
18998   }
18999 }
19000
19001
19002 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19003   char * jresult ;
19004   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19005   Dali::Property::Index arg2 ;
19006   std::string *result = 0 ;
19007
19008   arg1 = (Dali::TypeInfo *)jarg1;
19009   arg2 = (Dali::Property::Index)jarg2;
19010   {
19011     try {
19012       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19013     } catch (std::out_of_range& e) {
19014       {
19015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19016       };
19017     } catch (std::exception& e) {
19018       {
19019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19020       };
19021     } catch (...) {
19022       {
19023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19024       };
19025     }
19026   }
19027   jresult = SWIG_csharp_string_callback(result->c_str());
19028   return jresult;
19029 }
19030
19031
19032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19033   void * jresult ;
19034   Dali::TypeRegistry result;
19035
19036   {
19037     try {
19038       result = Dali::TypeRegistry::Get();
19039     } catch (std::out_of_range& e) {
19040       {
19041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19042       };
19043     } catch (std::exception& e) {
19044       {
19045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19050       };
19051     }
19052   }
19053   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19054   return jresult;
19055 }
19056
19057
19058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19059   void * jresult ;
19060   Dali::TypeRegistry *result = 0 ;
19061
19062   {
19063     try {
19064       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19065     } catch (std::out_of_range& e) {
19066       {
19067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19068       };
19069     } catch (std::exception& e) {
19070       {
19071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19072       };
19073     } catch (...) {
19074       {
19075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19076       };
19077     }
19078   }
19079   jresult = (void *)result;
19080   return jresult;
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19085   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19086
19087   arg1 = (Dali::TypeRegistry *)jarg1;
19088   {
19089     try {
19090       delete arg1;
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (...) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19102       };
19103     }
19104   }
19105 }
19106
19107
19108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19109   void * jresult ;
19110   Dali::TypeRegistry *arg1 = 0 ;
19111   Dali::TypeRegistry *result = 0 ;
19112
19113   arg1 = (Dali::TypeRegistry *)jarg1;
19114   if (!arg1) {
19115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19116     return 0;
19117   }
19118   {
19119     try {
19120       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19121     } catch (std::out_of_range& e) {
19122       {
19123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19124       };
19125     } catch (std::exception& e) {
19126       {
19127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19132       };
19133     }
19134   }
19135   jresult = (void *)result;
19136   return jresult;
19137 }
19138
19139
19140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19141   void * jresult ;
19142   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19143   Dali::TypeRegistry *arg2 = 0 ;
19144   Dali::TypeRegistry *result = 0 ;
19145
19146   arg1 = (Dali::TypeRegistry *)jarg1;
19147   arg2 = (Dali::TypeRegistry *)jarg2;
19148   if (!arg2) {
19149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19150     return 0;
19151   }
19152   {
19153     try {
19154       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19155     } catch (std::out_of_range& e) {
19156       {
19157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19158       };
19159     } catch (std::exception& e) {
19160       {
19161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (...) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19166       };
19167     }
19168   }
19169   jresult = (void *)result;
19170   return jresult;
19171 }
19172
19173
19174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19175   void * jresult ;
19176   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19177   std::string *arg2 = 0 ;
19178   Dali::TypeInfo result;
19179
19180   arg1 = (Dali::TypeRegistry *)jarg1;
19181   if (!jarg2) {
19182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19183     return 0;
19184   }
19185   std::string arg2_str(jarg2);
19186   arg2 = &arg2_str;
19187   {
19188     try {
19189       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19190     } catch (std::out_of_range& e) {
19191       {
19192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (std::exception& e) {
19195       {
19196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19201       };
19202     }
19203   }
19204   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19205
19206   //argout typemap for const std::string&
19207
19208   return jresult;
19209 }
19210
19211
19212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19213   void * jresult ;
19214   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19215   std::type_info *arg2 = 0 ;
19216   Dali::TypeInfo result;
19217
19218   arg1 = (Dali::TypeRegistry *)jarg1;
19219   arg2 = (std::type_info *)jarg2;
19220   if (!arg2) {
19221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19222     return 0;
19223   }
19224   {
19225     try {
19226       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19227     } catch (std::out_of_range& e) {
19228       {
19229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19230       };
19231     } catch (std::exception& e) {
19232       {
19233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19238       };
19239     }
19240   }
19241   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19242   return jresult;
19243 }
19244
19245
19246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19247   unsigned long jresult ;
19248   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19249   size_t result;
19250
19251   arg1 = (Dali::TypeRegistry *)jarg1;
19252   {
19253     try {
19254       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19255     } catch (std::out_of_range& e) {
19256       {
19257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19258       };
19259     } catch (std::exception& e) {
19260       {
19261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19262       };
19263     } catch (...) {
19264       {
19265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19266       };
19267     }
19268   }
19269   jresult = (unsigned long)result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19275   char * jresult ;
19276   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19277   size_t arg2 ;
19278   std::string result;
19279
19280   arg1 = (Dali::TypeRegistry *)jarg1;
19281   arg2 = (size_t)jarg2;
19282   {
19283     try {
19284       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19285     } catch (std::out_of_range& e) {
19286       {
19287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19288       };
19289     } catch (std::exception& e) {
19290       {
19291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19292       };
19293     } catch (...) {
19294       {
19295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19296       };
19297     }
19298   }
19299   jresult = SWIG_csharp_string_callback((&result)->c_str());
19300   return jresult;
19301 }
19302
19303
19304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19305   void * jresult ;
19306   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19307   Dali::TypeRegistry *result = 0 ;
19308
19309   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19310   {
19311     try {
19312       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19313     } catch (std::out_of_range& e) {
19314       {
19315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19316       };
19317     } catch (std::exception& e) {
19318       {
19319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (...) {
19322       {
19323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19324       };
19325     }
19326   }
19327   jresult = (void *)result;
19328   return jresult;
19329 }
19330
19331
19332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19333   void * jresult ;
19334   std::type_info *arg1 = 0 ;
19335   std::type_info *arg2 = 0 ;
19336   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19337   Dali::TypeRegistration *result = 0 ;
19338
19339   arg1 = (std::type_info *)jarg1;
19340   if (!arg1) {
19341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19342     return 0;
19343   }
19344   arg2 = (std::type_info *)jarg2;
19345   if (!arg2) {
19346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19347     return 0;
19348   }
19349   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19350   {
19351     try {
19352       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19353     } catch (std::out_of_range& e) {
19354       {
19355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19356       };
19357     } catch (std::exception& e) {
19358       {
19359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (...) {
19362       {
19363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19364       };
19365     }
19366   }
19367   jresult = (void *)result;
19368   return jresult;
19369 }
19370
19371
19372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19373   void * jresult ;
19374   std::type_info *arg1 = 0 ;
19375   std::type_info *arg2 = 0 ;
19376   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19377   bool arg4 ;
19378   Dali::TypeRegistration *result = 0 ;
19379
19380   arg1 = (std::type_info *)jarg1;
19381   if (!arg1) {
19382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19383     return 0;
19384   }
19385   arg2 = (std::type_info *)jarg2;
19386   if (!arg2) {
19387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19388     return 0;
19389   }
19390   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19391   arg4 = jarg4 ? true : false;
19392   {
19393     try {
19394       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19395     } catch (std::out_of_range& e) {
19396       {
19397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19398       };
19399     } catch (std::exception& e) {
19400       {
19401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19402       };
19403     } catch (...) {
19404       {
19405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19406       };
19407     }
19408   }
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19415   void * jresult ;
19416   std::string *arg1 = 0 ;
19417   std::type_info *arg2 = 0 ;
19418   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19419   Dali::TypeRegistration *result = 0 ;
19420
19421   if (!jarg1) {
19422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19423     return 0;
19424   }
19425   std::string arg1_str(jarg1);
19426   arg1 = &arg1_str;
19427   arg2 = (std::type_info *)jarg2;
19428   if (!arg2) {
19429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19430     return 0;
19431   }
19432   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19433   {
19434     try {
19435       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19436     } catch (std::out_of_range& e) {
19437       {
19438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19439       };
19440     } catch (std::exception& e) {
19441       {
19442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19443       };
19444     } catch (...) {
19445       {
19446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19447       };
19448     }
19449   }
19450   jresult = (void *)result;
19451
19452   //argout typemap for const std::string&
19453
19454   return jresult;
19455 }
19456
19457
19458 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19459   char * jresult ;
19460   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19461   std::string result;
19462
19463   arg1 = (Dali::TypeRegistration *)jarg1;
19464   {
19465     try {
19466       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19467     } catch (std::out_of_range& e) {
19468       {
19469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19470       };
19471     } catch (std::exception& e) {
19472       {
19473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19474       };
19475     } catch (...) {
19476       {
19477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19478       };
19479     }
19480   }
19481   jresult = SWIG_csharp_string_callback((&result)->c_str());
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19487   std::string *arg1 = 0 ;
19488   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19489
19490   if (!jarg1) {
19491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19492     return ;
19493   }
19494   std::string arg1_str(jarg1);
19495   arg1 = &arg1_str;
19496   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19497   {
19498     try {
19499       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19500     } catch (std::out_of_range& e) {
19501       {
19502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19503       };
19504     } catch (std::exception& e) {
19505       {
19506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19507       };
19508     } catch (...) {
19509       {
19510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19511       };
19512     }
19513   }
19514
19515   //argout typemap for const std::string&
19516
19517 }
19518
19519
19520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19521   std::string *arg1 = 0 ;
19522   std::string *arg2 = 0 ;
19523   int arg3 ;
19524   Dali::Property::Type arg4 ;
19525   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19526   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19527
19528   if (!jarg1) {
19529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19530     return ;
19531   }
19532   std::string arg1_str(jarg1);
19533   arg1 = &arg1_str;
19534   if (!jarg2) {
19535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19536     return ;
19537   }
19538   std::string arg2_str(jarg2);
19539   arg2 = &arg2_str;
19540   arg3 = (int)jarg3;
19541   arg4 = (Dali::Property::Type)jarg4;
19542   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19543   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19544   {
19545     try {
19546       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19547     } catch (std::out_of_range& e) {
19548       {
19549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19550       };
19551     } catch (std::exception& e) {
19552       {
19553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19554       };
19555     } catch (...) {
19556       {
19557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19558       };
19559     }
19560   }
19561
19562   //argout typemap for const std::string&
19563
19564
19565   //argout typemap for const std::string&
19566
19567 }
19568
19569
19570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19571   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19572
19573   arg1 = (Dali::TypeRegistration *)jarg1;
19574   {
19575     try {
19576       delete arg1;
19577     } catch (std::out_of_range& e) {
19578       {
19579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19580       };
19581     } catch (std::exception& e) {
19582       {
19583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19584       };
19585     } catch (...) {
19586       {
19587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19588       };
19589     }
19590   }
19591 }
19592
19593
19594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19595   void * jresult ;
19596   Dali::TypeRegistration *arg1 = 0 ;
19597   std::string *arg2 = 0 ;
19598   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19599   Dali::SignalConnectorType *result = 0 ;
19600
19601   arg1 = (Dali::TypeRegistration *)jarg1;
19602   if (!arg1) {
19603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19604     return 0;
19605   }
19606   if (!jarg2) {
19607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19608     return 0;
19609   }
19610   std::string arg2_str(jarg2);
19611   arg2 = &arg2_str;
19612   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19613   {
19614     try {
19615       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19616     } catch (std::out_of_range& e) {
19617       {
19618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19619       };
19620     } catch (std::exception& e) {
19621       {
19622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19623       };
19624     } catch (...) {
19625       {
19626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19627       };
19628     }
19629   }
19630   jresult = (void *)result;
19631
19632   //argout typemap for const std::string&
19633
19634   return jresult;
19635 }
19636
19637
19638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19639   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19640
19641   arg1 = (Dali::SignalConnectorType *)jarg1;
19642   {
19643     try {
19644       delete arg1;
19645     } catch (std::out_of_range& e) {
19646       {
19647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19648       };
19649     } catch (std::exception& e) {
19650       {
19651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19652       };
19653     } catch (...) {
19654       {
19655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19656       };
19657     }
19658   }
19659 }
19660
19661
19662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19663   void * jresult ;
19664   Dali::TypeRegistration *arg1 = 0 ;
19665   std::string *arg2 = 0 ;
19666   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19667   Dali::TypeAction *result = 0 ;
19668
19669   arg1 = (Dali::TypeRegistration *)jarg1;
19670   if (!arg1) {
19671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19672     return 0;
19673   }
19674   if (!jarg2) {
19675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19676     return 0;
19677   }
19678   std::string arg2_str(jarg2);
19679   arg2 = &arg2_str;
19680   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19681   {
19682     try {
19683       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19684     } catch (std::out_of_range& e) {
19685       {
19686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19687       };
19688     } catch (std::exception& e) {
19689       {
19690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19691       };
19692     } catch (...) {
19693       {
19694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19695       };
19696     }
19697   }
19698   jresult = (void *)result;
19699
19700   //argout typemap for const std::string&
19701
19702   return jresult;
19703 }
19704
19705
19706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19707   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19708
19709   arg1 = (Dali::TypeAction *)jarg1;
19710   {
19711     try {
19712       delete arg1;
19713     } catch (std::out_of_range& e) {
19714       {
19715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19716       };
19717     } catch (std::exception& e) {
19718       {
19719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19720       };
19721     } catch (...) {
19722       {
19723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19724       };
19725     }
19726   }
19727 }
19728
19729
19730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19731   void * jresult ;
19732   Dali::TypeRegistration *arg1 = 0 ;
19733   std::string *arg2 = 0 ;
19734   Dali::Property::Index arg3 ;
19735   Dali::Property::Type arg4 ;
19736   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19737   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19738   Dali::PropertyRegistration *result = 0 ;
19739
19740   arg1 = (Dali::TypeRegistration *)jarg1;
19741   if (!arg1) {
19742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19743     return 0;
19744   }
19745   if (!jarg2) {
19746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19747     return 0;
19748   }
19749   std::string arg2_str(jarg2);
19750   arg2 = &arg2_str;
19751   arg3 = (Dali::Property::Index)jarg3;
19752   arg4 = (Dali::Property::Type)jarg4;
19753   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19754   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19755   {
19756     try {
19757       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19758     } catch (std::out_of_range& e) {
19759       {
19760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19761       };
19762     } catch (std::exception& e) {
19763       {
19764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19765       };
19766     } catch (...) {
19767       {
19768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19769       };
19770     }
19771   }
19772   jresult = (void *)result;
19773
19774   //argout typemap for const std::string&
19775
19776   return jresult;
19777 }
19778
19779
19780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19781   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19782
19783   arg1 = (Dali::PropertyRegistration *)jarg1;
19784   {
19785     try {
19786       delete arg1;
19787     } catch (std::out_of_range& e) {
19788       {
19789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19790       };
19791     } catch (std::exception& e) {
19792       {
19793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19794       };
19795     } catch (...) {
19796       {
19797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19798       };
19799     }
19800   }
19801 }
19802
19803
19804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19805   void * jresult ;
19806   Dali::TypeRegistration *arg1 = 0 ;
19807   std::string *arg2 = 0 ;
19808   Dali::Property::Index arg3 ;
19809   Dali::Property::Type arg4 ;
19810   Dali::AnimatablePropertyRegistration *result = 0 ;
19811
19812   arg1 = (Dali::TypeRegistration *)jarg1;
19813   if (!arg1) {
19814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19815     return 0;
19816   }
19817   if (!jarg2) {
19818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19819     return 0;
19820   }
19821   std::string arg2_str(jarg2);
19822   arg2 = &arg2_str;
19823   arg3 = (Dali::Property::Index)jarg3;
19824   arg4 = (Dali::Property::Type)jarg4;
19825   {
19826     try {
19827       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19828     } catch (std::out_of_range& e) {
19829       {
19830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19831       };
19832     } catch (std::exception& e) {
19833       {
19834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (...) {
19837       {
19838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19839       };
19840     }
19841   }
19842   jresult = (void *)result;
19843
19844   //argout typemap for const std::string&
19845
19846   return jresult;
19847 }
19848
19849
19850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19851   void * jresult ;
19852   Dali::TypeRegistration *arg1 = 0 ;
19853   std::string *arg2 = 0 ;
19854   Dali::Property::Index arg3 ;
19855   Dali::Property::Value *arg4 = 0 ;
19856   Dali::AnimatablePropertyRegistration *result = 0 ;
19857
19858   arg1 = (Dali::TypeRegistration *)jarg1;
19859   if (!arg1) {
19860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19861     return 0;
19862   }
19863   if (!jarg2) {
19864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19865     return 0;
19866   }
19867   std::string arg2_str(jarg2);
19868   arg2 = &arg2_str;
19869   arg3 = (Dali::Property::Index)jarg3;
19870   arg4 = (Dali::Property::Value *)jarg4;
19871   if (!arg4) {
19872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19873     return 0;
19874   }
19875   {
19876     try {
19877       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19878     } catch (std::out_of_range& e) {
19879       {
19880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19881       };
19882     } catch (std::exception& e) {
19883       {
19884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19885       };
19886     } catch (...) {
19887       {
19888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19889       };
19890     }
19891   }
19892   jresult = (void *)result;
19893
19894   //argout typemap for const std::string&
19895
19896   return jresult;
19897 }
19898
19899
19900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19901   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19902
19903   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19904   {
19905     try {
19906       delete arg1;
19907     } catch (std::out_of_range& e) {
19908       {
19909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19910       };
19911     } catch (std::exception& e) {
19912       {
19913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19914       };
19915     } catch (...) {
19916       {
19917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19918       };
19919     }
19920   }
19921 }
19922
19923
19924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19925   void * jresult ;
19926   Dali::TypeRegistration *arg1 = 0 ;
19927   std::string *arg2 = 0 ;
19928   Dali::Property::Index arg3 ;
19929   Dali::Property::Index arg4 ;
19930   unsigned int arg5 ;
19931   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19932
19933   arg1 = (Dali::TypeRegistration *)jarg1;
19934   if (!arg1) {
19935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19936     return 0;
19937   }
19938   if (!jarg2) {
19939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19940     return 0;
19941   }
19942   std::string arg2_str(jarg2);
19943   arg2 = &arg2_str;
19944   arg3 = (Dali::Property::Index)jarg3;
19945   arg4 = (Dali::Property::Index)jarg4;
19946   arg5 = (unsigned int)jarg5;
19947   {
19948     try {
19949       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19950     } catch (std::out_of_range& e) {
19951       {
19952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19953       };
19954     } catch (std::exception& e) {
19955       {
19956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19957       };
19958     } catch (...) {
19959       {
19960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19961       };
19962     }
19963   }
19964   jresult = (void *)result;
19965
19966   //argout typemap for const std::string&
19967
19968   return jresult;
19969 }
19970
19971
19972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19973   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19974
19975   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19976   {
19977     try {
19978       delete arg1;
19979     } catch (std::out_of_range& e) {
19980       {
19981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19982       };
19983     } catch (std::exception& e) {
19984       {
19985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19986       };
19987     } catch (...) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19990       };
19991     }
19992   }
19993 }
19994
19995
19996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19997   void * jresult ;
19998   Dali::TypeRegistration *arg1 = 0 ;
19999   std::string *arg2 = 0 ;
20000   Dali::Property::Index arg3 ;
20001   Dali::Property::Type arg4 ;
20002   Dali::ChildPropertyRegistration *result = 0 ;
20003
20004   arg1 = (Dali::TypeRegistration *)jarg1;
20005   if (!arg1) {
20006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20007     return 0;
20008   }
20009   if (!jarg2) {
20010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20011     return 0;
20012   }
20013   std::string arg2_str(jarg2);
20014   arg2 = &arg2_str;
20015   arg3 = (Dali::Property::Index)jarg3;
20016   arg4 = (Dali::Property::Type)jarg4;
20017   {
20018     try {
20019       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20020     } catch (std::out_of_range& e) {
20021       {
20022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20023       };
20024     } catch (std::exception& e) {
20025       {
20026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20027       };
20028     } catch (...) {
20029       {
20030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20031       };
20032     }
20033   }
20034   jresult = (void *)result;
20035
20036   //argout typemap for const std::string&
20037
20038   return jresult;
20039 }
20040
20041
20042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20043   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20044
20045   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20046   {
20047     try {
20048       delete arg1;
20049     } catch (std::out_of_range& e) {
20050       {
20051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20052       };
20053     } catch (std::exception& e) {
20054       {
20055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20056       };
20057     } catch (...) {
20058       {
20059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20060       };
20061     }
20062   }
20063 }
20064
20065
20066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20067   unsigned int jresult ;
20068   std::string *arg1 = 0 ;
20069   std::type_info *arg2 = 0 ;
20070   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20071   bool result;
20072
20073   if (!jarg1) {
20074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20075     return 0;
20076   }
20077   std::string arg1_str(jarg1);
20078   arg1 = &arg1_str;
20079   arg2 = (std::type_info *)jarg2;
20080   if (!arg2) {
20081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20082     return 0;
20083   }
20084   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20085   {
20086     try {
20087       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20088     } catch (std::out_of_range& e) {
20089       {
20090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20091       };
20092     } catch (std::exception& e) {
20093       {
20094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20095       };
20096     } catch (...) {
20097       {
20098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20099       };
20100     }
20101   }
20102   jresult = result;
20103
20104   //argout typemap for const std::string&
20105
20106   return jresult;
20107 }
20108
20109
20110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20111   unsigned int jresult ;
20112   std::string *arg1 = 0 ;
20113   std::string *arg2 = 0 ;
20114   Dali::Property::Index arg3 ;
20115   Dali::Property::Type arg4 ;
20116   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20117   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20118   bool result;
20119
20120   if (!jarg1) {
20121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20122     return 0;
20123   }
20124   std::string arg1_str(jarg1);
20125   arg1 = &arg1_str;
20126   if (!jarg2) {
20127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20128     return 0;
20129   }
20130   std::string arg2_str(jarg2);
20131   arg2 = &arg2_str;
20132   arg3 = (Dali::Property::Index)jarg3;
20133   arg4 = (Dali::Property::Type)jarg4;
20134   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20135   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20136   {
20137     try {
20138       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20139     } catch (std::out_of_range& e) {
20140       {
20141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20142       };
20143     } catch (std::exception& e) {
20144       {
20145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20146       };
20147     } catch (...) {
20148       {
20149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20150       };
20151     }
20152   }
20153   jresult = result;
20154
20155   //argout typemap for const std::string&
20156
20157
20158   //argout typemap for const std::string&
20159
20160   return jresult;
20161 }
20162
20163
20164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20165   float jresult ;
20166   float result;
20167
20168   result = (float)(float)Dali::ParentOrigin::TOP;
20169   jresult = result;
20170   return jresult;
20171 }
20172
20173
20174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20175   float jresult ;
20176   float result;
20177
20178   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20179   jresult = result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20185   float jresult ;
20186   float result;
20187
20188   result = (float)(float)Dali::ParentOrigin::LEFT;
20189   jresult = result;
20190   return jresult;
20191 }
20192
20193
20194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20195   float jresult ;
20196   float result;
20197
20198   result = (float)(float)Dali::ParentOrigin::RIGHT;
20199   jresult = result;
20200   return jresult;
20201 }
20202
20203
20204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20205   float jresult ;
20206   float result;
20207
20208   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20209   jresult = result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20215   void * jresult ;
20216   Dali::Vector3 *result = 0 ;
20217
20218   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20219   jresult = (void *)result;
20220   return jresult;
20221 }
20222
20223
20224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20225   void * jresult ;
20226   Dali::Vector3 *result = 0 ;
20227
20228   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20229   jresult = (void *)result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20235   void * jresult ;
20236   Dali::Vector3 *result = 0 ;
20237
20238   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20239   jresult = (void *)result;
20240   return jresult;
20241 }
20242
20243
20244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20245   void * jresult ;
20246   Dali::Vector3 *result = 0 ;
20247
20248   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20249   jresult = (void *)result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20255   void * jresult ;
20256   Dali::Vector3 *result = 0 ;
20257
20258   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20259   jresult = (void *)result;
20260   return jresult;
20261 }
20262
20263
20264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20265   void * jresult ;
20266   Dali::Vector3 *result = 0 ;
20267
20268   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20269   jresult = (void *)result;
20270   return jresult;
20271 }
20272
20273
20274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20275   void * jresult ;
20276   Dali::Vector3 *result = 0 ;
20277
20278   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20279   jresult = (void *)result;
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20285   void * jresult ;
20286   Dali::Vector3 *result = 0 ;
20287
20288   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20289   jresult = (void *)result;
20290   return jresult;
20291 }
20292
20293
20294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20295   void * jresult ;
20296   Dali::Vector3 *result = 0 ;
20297
20298   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20299   jresult = (void *)result;
20300   return jresult;
20301 }
20302
20303
20304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20305   float jresult ;
20306   float result;
20307
20308   result = (float)(float)Dali::AnchorPoint::TOP;
20309   jresult = result;
20310   return jresult;
20311 }
20312
20313
20314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20315   float jresult ;
20316   float result;
20317
20318   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20319   jresult = result;
20320   return jresult;
20321 }
20322
20323
20324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20325   float jresult ;
20326   float result;
20327
20328   result = (float)(float)Dali::AnchorPoint::LEFT;
20329   jresult = result;
20330   return jresult;
20331 }
20332
20333
20334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20335   float jresult ;
20336   float result;
20337
20338   result = (float)(float)Dali::AnchorPoint::RIGHT;
20339   jresult = result;
20340   return jresult;
20341 }
20342
20343
20344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20345   float jresult ;
20346   float result;
20347
20348   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20349   jresult = result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20355   void * jresult ;
20356   Dali::Vector3 *result = 0 ;
20357
20358   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20359   jresult = (void *)result;
20360   return jresult;
20361 }
20362
20363
20364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20365   void * jresult ;
20366   Dali::Vector3 *result = 0 ;
20367
20368   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20375   void * jresult ;
20376   Dali::Vector3 *result = 0 ;
20377
20378   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20379   jresult = (void *)result;
20380   return jresult;
20381 }
20382
20383
20384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20385   void * jresult ;
20386   Dali::Vector3 *result = 0 ;
20387
20388   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20389   jresult = (void *)result;
20390   return jresult;
20391 }
20392
20393
20394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20395   void * jresult ;
20396   Dali::Vector3 *result = 0 ;
20397
20398   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20399   jresult = (void *)result;
20400   return jresult;
20401 }
20402
20403
20404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20405   void * jresult ;
20406   Dali::Vector3 *result = 0 ;
20407
20408   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20409   jresult = (void *)result;
20410   return jresult;
20411 }
20412
20413
20414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20415   void * jresult ;
20416   Dali::Vector3 *result = 0 ;
20417
20418   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20419   jresult = (void *)result;
20420   return jresult;
20421 }
20422
20423
20424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20425   void * jresult ;
20426   Dali::Vector3 *result = 0 ;
20427
20428   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20429   jresult = (void *)result;
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20435   void * jresult ;
20436   Dali::Vector3 *result = 0 ;
20437
20438   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20439   jresult = (void *)result;
20440   return jresult;
20441 }
20442
20443
20444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20445   void * jresult ;
20446   Dali::Vector4 *result = 0 ;
20447
20448   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20449   jresult = (void *)result;
20450   return jresult;
20451 }
20452
20453
20454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20455   void * jresult ;
20456   Dali::Vector4 *result = 0 ;
20457
20458   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20459   jresult = (void *)result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20465   void * jresult ;
20466   Dali::Vector4 *result = 0 ;
20467
20468   result = (Dali::Vector4 *)&Dali::Color::RED;
20469   jresult = (void *)result;
20470   return jresult;
20471 }
20472
20473
20474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20475   void * jresult ;
20476   Dali::Vector4 *result = 0 ;
20477
20478   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20479   jresult = (void *)result;
20480   return jresult;
20481 }
20482
20483
20484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20485   void * jresult ;
20486   Dali::Vector4 *result = 0 ;
20487
20488   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20489   jresult = (void *)result;
20490   return jresult;
20491 }
20492
20493
20494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20495   void * jresult ;
20496   Dali::Vector4 *result = 0 ;
20497
20498   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20499   jresult = (void *)result;
20500   return jresult;
20501 }
20502
20503
20504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20505   void * jresult ;
20506   Dali::Vector4 *result = 0 ;
20507
20508   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20509   jresult = (void *)result;
20510   return jresult;
20511 }
20512
20513
20514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20515   void * jresult ;
20516   Dali::Vector4 *result = 0 ;
20517
20518   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20519   jresult = (void *)result;
20520   return jresult;
20521 }
20522
20523
20524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20525   void * jresult ;
20526   Dali::Vector4 *result = 0 ;
20527
20528   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20529   jresult = (void *)result;
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20535   float jresult ;
20536   float result;
20537
20538   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20539   jresult = result;
20540   return jresult;
20541 }
20542
20543
20544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20545   float jresult ;
20546   float result;
20547
20548   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20549   jresult = result;
20550   return jresult;
20551 }
20552
20553
20554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20555   float jresult ;
20556   float result;
20557
20558   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20559   jresult = result;
20560   return jresult;
20561 }
20562
20563
20564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20565   float jresult ;
20566   float result;
20567
20568   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20569   jresult = result;
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20575   float jresult ;
20576   float result;
20577
20578   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20579   jresult = result;
20580   return jresult;
20581 }
20582
20583
20584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20585   float jresult ;
20586   float result;
20587
20588   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20589   jresult = result;
20590   return jresult;
20591 }
20592
20593
20594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20595   float jresult ;
20596   float result;
20597
20598   result = (float)(float)Dali::Math::PI;
20599   jresult = result;
20600   return jresult;
20601 }
20602
20603
20604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20605   float jresult ;
20606   float result;
20607
20608   result = (float)(float)Dali::Math::PI_2;
20609   jresult = result;
20610   return jresult;
20611 }
20612
20613
20614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20615   float jresult ;
20616   float result;
20617
20618   result = (float)(float)Dali::Math::PI_4;
20619   jresult = result;
20620   return jresult;
20621 }
20622
20623
20624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20625   float jresult ;
20626   float result;
20627
20628   result = (float)(float)Dali::Math::PI_OVER_180;
20629   jresult = result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20635   float jresult ;
20636   float result;
20637
20638   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20639   jresult = result;
20640   return jresult;
20641 }
20642
20643
20644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20645   int jresult ;
20646   Dali::ResizePolicy::Type result;
20647
20648   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20649   jresult = (int)result;
20650   return jresult;
20651 }
20652
20653
20654 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20655   unsigned long jresult ;
20656   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20657   Dali::VectorBase::SizeType result;
20658
20659   arg1 = (Dali::VectorBase *)jarg1;
20660   {
20661     try {
20662       result = ((Dali::VectorBase const *)arg1)->Count();
20663     } catch (std::out_of_range& e) {
20664       {
20665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (std::exception& e) {
20668       {
20669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20670       };
20671     } catch (...) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20674       };
20675     }
20676   }
20677   jresult = (unsigned long)result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20683   unsigned long jresult ;
20684   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20685   Dali::VectorBase::SizeType result;
20686
20687   arg1 = (Dali::VectorBase *)jarg1;
20688   {
20689     try {
20690       result = ((Dali::VectorBase const *)arg1)->Size();
20691     } catch (std::out_of_range& e) {
20692       {
20693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20694       };
20695     } catch (std::exception& e) {
20696       {
20697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20698       };
20699     } catch (...) {
20700       {
20701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20702       };
20703     }
20704   }
20705   jresult = (unsigned long)result;
20706   return jresult;
20707 }
20708
20709
20710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20711   unsigned int jresult ;
20712   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20713   bool result;
20714
20715   arg1 = (Dali::VectorBase *)jarg1;
20716   {
20717     try {
20718       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20719     } catch (std::out_of_range& e) {
20720       {
20721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20722       };
20723     } catch (std::exception& e) {
20724       {
20725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20726       };
20727     } catch (...) {
20728       {
20729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20730       };
20731     }
20732   }
20733   jresult = result;
20734   return jresult;
20735 }
20736
20737
20738 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20739   unsigned long jresult ;
20740   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20741   Dali::VectorBase::SizeType result;
20742
20743   arg1 = (Dali::VectorBase *)jarg1;
20744   {
20745     try {
20746       result = ((Dali::VectorBase const *)arg1)->Capacity();
20747     } catch (std::out_of_range& e) {
20748       {
20749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20750       };
20751     } catch (std::exception& e) {
20752       {
20753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20754       };
20755     } catch (...) {
20756       {
20757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20758       };
20759     }
20760   }
20761   jresult = (unsigned long)result;
20762   return jresult;
20763 }
20764
20765
20766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20767   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20768
20769   arg1 = (Dali::VectorBase *)jarg1;
20770   {
20771     try {
20772       (arg1)->Release();
20773     } catch (std::out_of_range& e) {
20774       {
20775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20776       };
20777     } catch (std::exception& e) {
20778       {
20779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20780       };
20781     } catch (...) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20784       };
20785     }
20786   }
20787 }
20788
20789
20790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20791   void * jresult ;
20792   Dali::Image *result = 0 ;
20793
20794   {
20795     try {
20796       result = (Dali::Image *)new Dali::Image();
20797     } catch (std::out_of_range& e) {
20798       {
20799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20800       };
20801     } catch (std::exception& e) {
20802       {
20803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20804       };
20805     } catch (...) {
20806       {
20807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20808       };
20809     }
20810   }
20811   jresult = (void *)result;
20812   return jresult;
20813 }
20814
20815
20816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20817   Dali::Image *arg1 = (Dali::Image *) 0 ;
20818
20819   arg1 = (Dali::Image *)jarg1;
20820   {
20821     try {
20822       delete arg1;
20823     } catch (std::out_of_range& e) {
20824       {
20825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20826       };
20827     } catch (std::exception& e) {
20828       {
20829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20830       };
20831     } catch (...) {
20832       {
20833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20834       };
20835     }
20836   }
20837 }
20838
20839
20840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20841   void * jresult ;
20842   Dali::Image *arg1 = 0 ;
20843   Dali::Image *result = 0 ;
20844
20845   arg1 = (Dali::Image *)jarg1;
20846   if (!arg1) {
20847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20848     return 0;
20849   }
20850   {
20851     try {
20852       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20853     } catch (std::out_of_range& e) {
20854       {
20855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20856       };
20857     } catch (std::exception& e) {
20858       {
20859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20860       };
20861     } catch (...) {
20862       {
20863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20864       };
20865     }
20866   }
20867   jresult = (void *)result;
20868   return jresult;
20869 }
20870
20871
20872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20873   void * jresult ;
20874   Dali::Image *arg1 = (Dali::Image *) 0 ;
20875   Dali::Image *arg2 = 0 ;
20876   Dali::Image *result = 0 ;
20877
20878   arg1 = (Dali::Image *)jarg1;
20879   arg2 = (Dali::Image *)jarg2;
20880   if (!arg2) {
20881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20882     return 0;
20883   }
20884   {
20885     try {
20886       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20887     } catch (std::out_of_range& e) {
20888       {
20889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20890       };
20891     } catch (std::exception& e) {
20892       {
20893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20894       };
20895     } catch (...) {
20896       {
20897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20898       };
20899     }
20900   }
20901   jresult = (void *)result;
20902   return jresult;
20903 }
20904
20905
20906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20907   void * jresult ;
20908   Dali::BaseHandle arg1 ;
20909   Dali::BaseHandle *argp1 ;
20910   Dali::Image result;
20911
20912   argp1 = (Dali::BaseHandle *)jarg1;
20913   if (!argp1) {
20914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20915     return 0;
20916   }
20917   arg1 = *argp1;
20918   {
20919     try {
20920       result = Dali::Image::DownCast(arg1);
20921     } catch (std::out_of_range& e) {
20922       {
20923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20924       };
20925     } catch (std::exception& e) {
20926       {
20927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20928       };
20929     } catch (...) {
20930       {
20931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20932       };
20933     }
20934   }
20935   jresult = new Dali::Image((const Dali::Image &)result);
20936   return jresult;
20937 }
20938
20939
20940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20941   unsigned int jresult ;
20942   Dali::Image *arg1 = (Dali::Image *) 0 ;
20943   unsigned int result;
20944
20945   arg1 = (Dali::Image *)jarg1;
20946   {
20947     try {
20948       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20949     } catch (std::out_of_range& e) {
20950       {
20951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20952       };
20953     } catch (std::exception& e) {
20954       {
20955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20956       };
20957     } catch (...) {
20958       {
20959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20960       };
20961     }
20962   }
20963   jresult = result;
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20969   unsigned int jresult ;
20970   Dali::Image *arg1 = (Dali::Image *) 0 ;
20971   unsigned int result;
20972
20973   arg1 = (Dali::Image *)jarg1;
20974   {
20975     try {
20976       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20977     } catch (std::out_of_range& e) {
20978       {
20979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20980       };
20981     } catch (std::exception& e) {
20982       {
20983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20984       };
20985     } catch (...) {
20986       {
20987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20988       };
20989     }
20990   }
20991   jresult = result;
20992   return jresult;
20993 }
20994
20995
20996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20997   void * jresult ;
20998   Dali::Image *arg1 = (Dali::Image *) 0 ;
20999   Dali::Image::ImageSignalType *result = 0 ;
21000
21001   arg1 = (Dali::Image *)jarg1;
21002   {
21003     try {
21004       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21005     } catch (std::out_of_range& e) {
21006       {
21007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21008       };
21009     } catch (std::exception& e) {
21010       {
21011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21012       };
21013     } catch (...) {
21014       {
21015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21016       };
21017     }
21018   }
21019   jresult = (void *)result;
21020   return jresult;
21021 }
21022
21023
21024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21025   int jresult ;
21026   Dali::Pixel::Format result;
21027
21028   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21029   jresult = (int)result;
21030   return jresult;
21031 }
21032
21033
21034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21035   int jresult ;
21036   Dali::Pixel::Format result;
21037
21038   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21039   jresult = (int)result;
21040   return jresult;
21041 }
21042
21043
21044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21045   unsigned int jresult ;
21046   Dali::Pixel::Format arg1 ;
21047   bool result;
21048
21049   arg1 = (Dali::Pixel::Format)jarg1;
21050   {
21051     try {
21052       result = (bool)Dali::Pixel::HasAlpha(arg1);
21053     } catch (std::out_of_range& e) {
21054       {
21055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21056       };
21057     } catch (std::exception& e) {
21058       {
21059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21060       };
21061     } catch (...) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21064       };
21065     }
21066   }
21067   jresult = result;
21068   return jresult;
21069 }
21070
21071
21072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21073   unsigned int jresult ;
21074   Dali::Pixel::Format arg1 ;
21075   unsigned int result;
21076
21077   arg1 = (Dali::Pixel::Format)jarg1;
21078   {
21079     try {
21080       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21081     } catch (std::out_of_range& e) {
21082       {
21083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21084       };
21085     } catch (std::exception& e) {
21086       {
21087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21088       };
21089     } catch (...) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21092       };
21093     }
21094   }
21095   jresult = result;
21096   return jresult;
21097 }
21098
21099
21100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21101   Dali::Pixel::Format arg1 ;
21102   int *arg2 = 0 ;
21103   int *arg3 = 0 ;
21104
21105   arg1 = (Dali::Pixel::Format)jarg1;
21106   arg2 = (int *)jarg2;
21107   if (!arg2) {
21108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21109     return ;
21110   }
21111   arg3 = (int *)jarg3;
21112   if (!arg3) {
21113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21114     return ;
21115   }
21116   {
21117     try {
21118       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21119     } catch (std::out_of_range& e) {
21120       {
21121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21122       };
21123     } catch (std::exception& e) {
21124       {
21125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21130       };
21131     }
21132   }
21133 }
21134
21135
21136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21137   void * jresult ;
21138   unsigned char *arg1 = (unsigned char *) 0 ;
21139   unsigned int arg2 ;
21140   unsigned int arg3 ;
21141   unsigned int arg4 ;
21142   Dali::Pixel::Format arg5 ;
21143   Dali::PixelData::ReleaseFunction arg6 ;
21144   Dali::PixelData result;
21145
21146   arg1 = jarg1;
21147   arg2 = (unsigned int)jarg2;
21148   arg3 = (unsigned int)jarg3;
21149   arg4 = (unsigned int)jarg4;
21150   arg5 = (Dali::Pixel::Format)jarg5;
21151   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21152   {
21153     try {
21154       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21155     } catch (std::out_of_range& e) {
21156       {
21157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21158       };
21159     } catch (std::exception& e) {
21160       {
21161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21166       };
21167     }
21168   }
21169   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21170
21171
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21177   void * jresult ;
21178   Dali::PixelData *result = 0 ;
21179
21180   {
21181     try {
21182       result = (Dali::PixelData *)new Dali::PixelData();
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 (...) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21194       };
21195     }
21196   }
21197   jresult = (void *)result;
21198   return jresult;
21199 }
21200
21201
21202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21203   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21204
21205   arg1 = (Dali::PixelData *)jarg1;
21206   {
21207     try {
21208       delete arg1;
21209     } catch (std::out_of_range& e) {
21210       {
21211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21212       };
21213     } catch (std::exception& e) {
21214       {
21215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21216       };
21217     } catch (...) {
21218       {
21219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21220       };
21221     }
21222   }
21223 }
21224
21225
21226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21227   void * jresult ;
21228   Dali::PixelData *arg1 = 0 ;
21229   Dali::PixelData *result = 0 ;
21230
21231   arg1 = (Dali::PixelData *)jarg1;
21232   if (!arg1) {
21233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21234     return 0;
21235   }
21236   {
21237     try {
21238       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21239     } catch (std::out_of_range& e) {
21240       {
21241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21242       };
21243     } catch (std::exception& e) {
21244       {
21245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21246       };
21247     } catch (...) {
21248       {
21249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21250       };
21251     }
21252   }
21253   jresult = (void *)result;
21254   return jresult;
21255 }
21256
21257
21258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21259   void * jresult ;
21260   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21261   Dali::PixelData *arg2 = 0 ;
21262   Dali::PixelData *result = 0 ;
21263
21264   arg1 = (Dali::PixelData *)jarg1;
21265   arg2 = (Dali::PixelData *)jarg2;
21266   if (!arg2) {
21267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21268     return 0;
21269   }
21270   {
21271     try {
21272       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21273     } catch (std::out_of_range& e) {
21274       {
21275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21276       };
21277     } catch (std::exception& e) {
21278       {
21279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21280       };
21281     } catch (...) {
21282       {
21283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21284       };
21285     }
21286   }
21287   jresult = (void *)result;
21288   return jresult;
21289 }
21290
21291
21292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21293   unsigned int jresult ;
21294   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21295   unsigned int result;
21296
21297   arg1 = (Dali::PixelData *)jarg1;
21298   {
21299     try {
21300       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21301     } catch (std::out_of_range& e) {
21302       {
21303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21304       };
21305     } catch (std::exception& e) {
21306       {
21307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21308       };
21309     } catch (...) {
21310       {
21311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21312       };
21313     }
21314   }
21315   jresult = result;
21316   return jresult;
21317 }
21318
21319
21320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21321   unsigned int jresult ;
21322   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21323   unsigned int result;
21324
21325   arg1 = (Dali::PixelData *)jarg1;
21326   {
21327     try {
21328       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21329     } catch (std::out_of_range& e) {
21330       {
21331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21332       };
21333     } catch (std::exception& e) {
21334       {
21335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21336       };
21337     } catch (...) {
21338       {
21339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21340       };
21341     }
21342   }
21343   jresult = result;
21344   return jresult;
21345 }
21346
21347
21348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21349   int jresult ;
21350   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21351   Dali::Pixel::Format result;
21352
21353   arg1 = (Dali::PixelData *)jarg1;
21354   {
21355     try {
21356       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21357     } catch (std::out_of_range& e) {
21358       {
21359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (std::exception& e) {
21362       {
21363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21364       };
21365     } catch (...) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21368       };
21369     }
21370   }
21371   jresult = (int)result;
21372   return jresult;
21373 }
21374
21375
21376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21377   unsigned int jresult ;
21378   unsigned int result;
21379
21380   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21381   jresult = result;
21382   return jresult;
21383 }
21384
21385
21386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21387   unsigned int jresult ;
21388   unsigned int result;
21389
21390   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21391   jresult = result;
21392   return jresult;
21393 }
21394
21395
21396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21397   unsigned int jresult ;
21398   unsigned int result;
21399
21400   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21401   jresult = result;
21402   return jresult;
21403 }
21404
21405
21406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21407   unsigned int jresult ;
21408   unsigned int result;
21409
21410   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21411   jresult = result;
21412   return jresult;
21413 }
21414
21415
21416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21417   unsigned int jresult ;
21418   unsigned int result;
21419
21420   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21421   jresult = result;
21422   return jresult;
21423 }
21424
21425
21426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21427   unsigned int jresult ;
21428   unsigned int result;
21429
21430   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21431   jresult = result;
21432   return jresult;
21433 }
21434
21435
21436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21437   void * jresult ;
21438   Dali::TextureType::Type arg1 ;
21439   Dali::Pixel::Format arg2 ;
21440   unsigned int arg3 ;
21441   unsigned int arg4 ;
21442   Dali::Texture result;
21443
21444   arg1 = (Dali::TextureType::Type)jarg1;
21445   arg2 = (Dali::Pixel::Format)jarg2;
21446   arg3 = (unsigned int)jarg3;
21447   arg4 = (unsigned int)jarg4;
21448   {
21449     try {
21450       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21451     } catch (std::out_of_range& e) {
21452       {
21453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21454       };
21455     } catch (std::exception& e) {
21456       {
21457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (...) {
21460       {
21461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21462       };
21463     }
21464   }
21465   jresult = new Dali::Texture((const Dali::Texture &)result);
21466   return jresult;
21467 }
21468
21469
21470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21471   void * jresult ;
21472   NativeImageInterface *arg1 = 0 ;
21473   Dali::Texture result;
21474
21475   arg1 = (NativeImageInterface *)jarg1;
21476   if (!arg1) {
21477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21478     return 0;
21479   }
21480   {
21481     try {
21482       result = Dali::Texture::New(*arg1);
21483     } catch (std::out_of_range& e) {
21484       {
21485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21486       };
21487     } catch (std::exception& e) {
21488       {
21489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (...) {
21492       {
21493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21494       };
21495     }
21496   }
21497   jresult = new Dali::Texture((const Dali::Texture &)result);
21498   return jresult;
21499 }
21500
21501
21502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21503   void * jresult ;
21504   Dali::Texture *result = 0 ;
21505
21506   {
21507     try {
21508       result = (Dali::Texture *)new Dali::Texture();
21509     } catch (std::out_of_range& e) {
21510       {
21511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21512       };
21513     } catch (std::exception& e) {
21514       {
21515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21516       };
21517     } catch (...) {
21518       {
21519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21520       };
21521     }
21522   }
21523   jresult = (void *)result;
21524   return jresult;
21525 }
21526
21527
21528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21529   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21530
21531   arg1 = (Dali::Texture *)jarg1;
21532   {
21533     try {
21534       delete arg1;
21535     } catch (std::out_of_range& e) {
21536       {
21537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21538       };
21539     } catch (std::exception& e) {
21540       {
21541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21542       };
21543     } catch (...) {
21544       {
21545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21546       };
21547     }
21548   }
21549 }
21550
21551
21552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21553   void * jresult ;
21554   Dali::Texture *arg1 = 0 ;
21555   Dali::Texture *result = 0 ;
21556
21557   arg1 = (Dali::Texture *)jarg1;
21558   if (!arg1) {
21559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21560     return 0;
21561   }
21562   {
21563     try {
21564       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21565     } catch (std::out_of_range& e) {
21566       {
21567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21568       };
21569     } catch (std::exception& e) {
21570       {
21571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21572       };
21573     } catch (...) {
21574       {
21575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21576       };
21577     }
21578   }
21579   jresult = (void *)result;
21580   return jresult;
21581 }
21582
21583
21584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21585   void * jresult ;
21586   Dali::BaseHandle arg1 ;
21587   Dali::BaseHandle *argp1 ;
21588   Dali::Texture result;
21589
21590   argp1 = (Dali::BaseHandle *)jarg1;
21591   if (!argp1) {
21592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21593     return 0;
21594   }
21595   arg1 = *argp1;
21596   {
21597     try {
21598       result = Dali::Texture::DownCast(arg1);
21599     } catch (std::out_of_range& e) {
21600       {
21601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21602       };
21603     } catch (std::exception& e) {
21604       {
21605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21610       };
21611     }
21612   }
21613   jresult = new Dali::Texture((const Dali::Texture &)result);
21614   return jresult;
21615 }
21616
21617
21618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21619   void * jresult ;
21620   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21621   Dali::Texture *arg2 = 0 ;
21622   Dali::Texture *result = 0 ;
21623
21624   arg1 = (Dali::Texture *)jarg1;
21625   arg2 = (Dali::Texture *)jarg2;
21626   if (!arg2) {
21627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21628     return 0;
21629   }
21630   {
21631     try {
21632       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21633     } catch (std::out_of_range& e) {
21634       {
21635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21636       };
21637     } catch (std::exception& e) {
21638       {
21639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21640       };
21641     } catch (...) {
21642       {
21643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21644       };
21645     }
21646   }
21647   jresult = (void *)result;
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21653   unsigned int jresult ;
21654   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21655   Dali::PixelData arg2 ;
21656   Dali::PixelData *argp2 ;
21657   bool result;
21658
21659   arg1 = (Dali::Texture *)jarg1;
21660   argp2 = (Dali::PixelData *)jarg2;
21661   if (!argp2) {
21662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21663     return 0;
21664   }
21665   arg2 = *argp2;
21666   {
21667     try {
21668       result = (bool)(arg1)->Upload(arg2);
21669     } catch (std::out_of_range& e) {
21670       {
21671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21672       };
21673     } catch (std::exception& e) {
21674       {
21675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21676       };
21677     } catch (...) {
21678       {
21679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21680       };
21681     }
21682   }
21683   jresult = result;
21684   return jresult;
21685 }
21686
21687
21688 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) {
21689   unsigned int jresult ;
21690   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21691   Dali::PixelData arg2 ;
21692   unsigned int arg3 ;
21693   unsigned int arg4 ;
21694   unsigned int arg5 ;
21695   unsigned int arg6 ;
21696   unsigned int arg7 ;
21697   unsigned int arg8 ;
21698   Dali::PixelData *argp2 ;
21699   bool result;
21700
21701   arg1 = (Dali::Texture *)jarg1;
21702   argp2 = (Dali::PixelData *)jarg2;
21703   if (!argp2) {
21704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21705     return 0;
21706   }
21707   arg2 = *argp2;
21708   arg3 = (unsigned int)jarg3;
21709   arg4 = (unsigned int)jarg4;
21710   arg5 = (unsigned int)jarg5;
21711   arg6 = (unsigned int)jarg6;
21712   arg7 = (unsigned int)jarg7;
21713   arg8 = (unsigned int)jarg8;
21714   {
21715     try {
21716       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21717     } catch (std::out_of_range& e) {
21718       {
21719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21720       };
21721     } catch (std::exception& e) {
21722       {
21723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21728       };
21729     }
21730   }
21731   jresult = result;
21732   return jresult;
21733 }
21734
21735
21736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21737   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21738
21739   arg1 = (Dali::Texture *)jarg1;
21740   {
21741     try {
21742       (arg1)->GenerateMipmaps();
21743     } catch (std::out_of_range& e) {
21744       {
21745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21746       };
21747     } catch (std::exception& e) {
21748       {
21749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21750       };
21751     } catch (...) {
21752       {
21753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21754       };
21755     }
21756   }
21757 }
21758
21759
21760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21761   unsigned int jresult ;
21762   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21763   unsigned int result;
21764
21765   arg1 = (Dali::Texture *)jarg1;
21766   {
21767     try {
21768       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21769     } catch (std::out_of_range& e) {
21770       {
21771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21772       };
21773     } catch (std::exception& e) {
21774       {
21775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21776       };
21777     } catch (...) {
21778       {
21779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21780       };
21781     }
21782   }
21783   jresult = result;
21784   return jresult;
21785 }
21786
21787
21788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21789   unsigned int jresult ;
21790   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21791   unsigned int result;
21792
21793   arg1 = (Dali::Texture *)jarg1;
21794   {
21795     try {
21796       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21797     } catch (std::out_of_range& e) {
21798       {
21799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (std::exception& e) {
21802       {
21803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811   jresult = result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21817   void * jresult ;
21818   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21819   Dali::Texture *result = 0 ;
21820
21821   arg1 = (Dali::Internal::Texture *)jarg1;
21822   {
21823     try {
21824       result = (Dali::Texture *)new Dali::Texture(arg1);
21825     } catch (std::out_of_range& e) {
21826       {
21827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21828       };
21829     } catch (std::exception& e) {
21830       {
21831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (...) {
21834       {
21835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21836       };
21837     }
21838   }
21839   jresult = (void *)result;
21840   return jresult;
21841 }
21842
21843
21844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21845   void * jresult ;
21846   Dali::Sampler result;
21847
21848   {
21849     try {
21850       result = Dali::Sampler::New();
21851     } catch (std::out_of_range& e) {
21852       {
21853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21854       };
21855     } catch (std::exception& e) {
21856       {
21857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (...) {
21860       {
21861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21862       };
21863     }
21864   }
21865   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21866   return jresult;
21867 }
21868
21869
21870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21871   void * jresult ;
21872   Dali::Sampler *result = 0 ;
21873
21874   {
21875     try {
21876       result = (Dali::Sampler *)new Dali::Sampler();
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (...) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21888       };
21889     }
21890   }
21891   jresult = (void *)result;
21892   return jresult;
21893 }
21894
21895
21896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21897   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21898
21899   arg1 = (Dali::Sampler *)jarg1;
21900   {
21901     try {
21902       delete arg1;
21903     } catch (std::out_of_range& e) {
21904       {
21905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21906       };
21907     } catch (std::exception& e) {
21908       {
21909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21910       };
21911     } catch (...) {
21912       {
21913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21914       };
21915     }
21916   }
21917 }
21918
21919
21920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21921   void * jresult ;
21922   Dali::Sampler *arg1 = 0 ;
21923   Dali::Sampler *result = 0 ;
21924
21925   arg1 = (Dali::Sampler *)jarg1;
21926   if (!arg1) {
21927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21928     return 0;
21929   }
21930   {
21931     try {
21932       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21933     } catch (std::out_of_range& e) {
21934       {
21935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21936       };
21937     } catch (std::exception& e) {
21938       {
21939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21940       };
21941     } catch (...) {
21942       {
21943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21944       };
21945     }
21946   }
21947   jresult = (void *)result;
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21953   void * jresult ;
21954   Dali::BaseHandle arg1 ;
21955   Dali::BaseHandle *argp1 ;
21956   Dali::Sampler result;
21957
21958   argp1 = (Dali::BaseHandle *)jarg1;
21959   if (!argp1) {
21960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21961     return 0;
21962   }
21963   arg1 = *argp1;
21964   {
21965     try {
21966       result = Dali::Sampler::DownCast(arg1);
21967     } catch (std::out_of_range& e) {
21968       {
21969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21970       };
21971     } catch (std::exception& e) {
21972       {
21973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21974       };
21975     } catch (...) {
21976       {
21977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21978       };
21979     }
21980   }
21981   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21982   return jresult;
21983 }
21984
21985
21986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21987   void * jresult ;
21988   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21989   Dali::Sampler *arg2 = 0 ;
21990   Dali::Sampler *result = 0 ;
21991
21992   arg1 = (Dali::Sampler *)jarg1;
21993   arg2 = (Dali::Sampler *)jarg2;
21994   if (!arg2) {
21995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21996     return 0;
21997   }
21998   {
21999     try {
22000       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22001     } catch (std::out_of_range& e) {
22002       {
22003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22004       };
22005     } catch (std::exception& e) {
22006       {
22007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22008       };
22009     } catch (...) {
22010       {
22011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22012       };
22013     }
22014   }
22015   jresult = (void *)result;
22016   return jresult;
22017 }
22018
22019
22020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22021   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22022   Dali::FilterMode::Type arg2 ;
22023   Dali::FilterMode::Type arg3 ;
22024
22025   arg1 = (Dali::Sampler *)jarg1;
22026   arg2 = (Dali::FilterMode::Type)jarg2;
22027   arg3 = (Dali::FilterMode::Type)jarg3;
22028   {
22029     try {
22030       (arg1)->SetFilterMode(arg2,arg3);
22031     } catch (std::out_of_range& e) {
22032       {
22033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22034       };
22035     } catch (std::exception& e) {
22036       {
22037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22038       };
22039     } catch (...) {
22040       {
22041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22042       };
22043     }
22044   }
22045 }
22046
22047
22048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22049   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22050   Dali::WrapMode::Type arg2 ;
22051   Dali::WrapMode::Type arg3 ;
22052
22053   arg1 = (Dali::Sampler *)jarg1;
22054   arg2 = (Dali::WrapMode::Type)jarg2;
22055   arg3 = (Dali::WrapMode::Type)jarg3;
22056   {
22057     try {
22058       (arg1)->SetWrapMode(arg2,arg3);
22059     } catch (std::out_of_range& e) {
22060       {
22061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22062       };
22063     } catch (std::exception& e) {
22064       {
22065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22066       };
22067     } catch (...) {
22068       {
22069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22070       };
22071     }
22072   }
22073 }
22074
22075
22076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22077   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22078   Dali::WrapMode::Type arg2 ;
22079   Dali::WrapMode::Type arg3 ;
22080   Dali::WrapMode::Type arg4 ;
22081
22082   arg1 = (Dali::Sampler *)jarg1;
22083   arg2 = (Dali::WrapMode::Type)jarg2;
22084   arg3 = (Dali::WrapMode::Type)jarg3;
22085   arg4 = (Dali::WrapMode::Type)jarg4;
22086   {
22087     try {
22088       (arg1)->SetWrapMode(arg2,arg3,arg4);
22089     } catch (std::out_of_range& e) {
22090       {
22091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22092       };
22093     } catch (std::exception& e) {
22094       {
22095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22096       };
22097     } catch (...) {
22098       {
22099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22100       };
22101     }
22102   }
22103 }
22104
22105
22106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22107   void * jresult ;
22108   Dali::TextureSet result;
22109
22110   {
22111     try {
22112       result = Dali::TextureSet::New();
22113     } catch (std::out_of_range& e) {
22114       {
22115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22116       };
22117     } catch (std::exception& e) {
22118       {
22119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (...) {
22122       {
22123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22124       };
22125     }
22126   }
22127   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22128   return jresult;
22129 }
22130
22131
22132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22133   void * jresult ;
22134   Dali::TextureSet *result = 0 ;
22135
22136   {
22137     try {
22138       result = (Dali::TextureSet *)new Dali::TextureSet();
22139     } catch (std::out_of_range& e) {
22140       {
22141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22142       };
22143     } catch (std::exception& e) {
22144       {
22145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22146       };
22147     } catch (...) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22150       };
22151     }
22152   }
22153   jresult = (void *)result;
22154   return jresult;
22155 }
22156
22157
22158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22159   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22160
22161   arg1 = (Dali::TextureSet *)jarg1;
22162   {
22163     try {
22164       delete arg1;
22165     } catch (std::out_of_range& e) {
22166       {
22167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22168       };
22169     } catch (std::exception& e) {
22170       {
22171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22172       };
22173     } catch (...) {
22174       {
22175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22176       };
22177     }
22178   }
22179 }
22180
22181
22182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22183   void * jresult ;
22184   Dali::TextureSet *arg1 = 0 ;
22185   Dali::TextureSet *result = 0 ;
22186
22187   arg1 = (Dali::TextureSet *)jarg1;
22188   if (!arg1) {
22189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22190     return 0;
22191   }
22192   {
22193     try {
22194       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22195     } catch (std::out_of_range& e) {
22196       {
22197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22198       };
22199     } catch (std::exception& e) {
22200       {
22201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22202       };
22203     } catch (...) {
22204       {
22205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22206       };
22207     }
22208   }
22209   jresult = (void *)result;
22210   return jresult;
22211 }
22212
22213
22214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22215   void * jresult ;
22216   Dali::BaseHandle arg1 ;
22217   Dali::BaseHandle *argp1 ;
22218   Dali::TextureSet result;
22219
22220   argp1 = (Dali::BaseHandle *)jarg1;
22221   if (!argp1) {
22222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22223     return 0;
22224   }
22225   arg1 = *argp1;
22226   {
22227     try {
22228       result = Dali::TextureSet::DownCast(arg1);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22236       };
22237     } catch (...) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22240       };
22241     }
22242   }
22243   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22244   return jresult;
22245 }
22246
22247
22248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22249   void * jresult ;
22250   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22251   Dali::TextureSet *arg2 = 0 ;
22252   Dali::TextureSet *result = 0 ;
22253
22254   arg1 = (Dali::TextureSet *)jarg1;
22255   arg2 = (Dali::TextureSet *)jarg2;
22256   if (!arg2) {
22257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22258     return 0;
22259   }
22260   {
22261     try {
22262       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22270       };
22271     } catch (...) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22274       };
22275     }
22276   }
22277   jresult = (void *)result;
22278   return jresult;
22279 }
22280
22281
22282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22283   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22284   size_t arg2 ;
22285   Dali::Texture arg3 ;
22286   Dali::Texture *argp3 ;
22287
22288   arg1 = (Dali::TextureSet *)jarg1;
22289   arg2 = (size_t)jarg2;
22290   argp3 = (Dali::Texture *)jarg3;
22291   if (!argp3) {
22292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22293     return ;
22294   }
22295   arg3 = *argp3;
22296   {
22297     try {
22298       (arg1)->SetTexture(arg2,arg3);
22299     } catch (std::out_of_range& e) {
22300       {
22301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22302       };
22303     } catch (std::exception& e) {
22304       {
22305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22306       };
22307     } catch (...) {
22308       {
22309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22310       };
22311     }
22312   }
22313 }
22314
22315
22316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22317   void * jresult ;
22318   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22319   size_t arg2 ;
22320   Dali::Texture result;
22321
22322   arg1 = (Dali::TextureSet *)jarg1;
22323   arg2 = (size_t)jarg2;
22324   {
22325     try {
22326       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22327     } catch (std::out_of_range& e) {
22328       {
22329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22330       };
22331     } catch (std::exception& e) {
22332       {
22333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22334       };
22335     } catch (...) {
22336       {
22337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22338       };
22339     }
22340   }
22341   jresult = new Dali::Texture((const Dali::Texture &)result);
22342   return jresult;
22343 }
22344
22345
22346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22347   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22348   size_t arg2 ;
22349   Dali::Sampler arg3 ;
22350   Dali::Sampler *argp3 ;
22351
22352   arg1 = (Dali::TextureSet *)jarg1;
22353   arg2 = (size_t)jarg2;
22354   argp3 = (Dali::Sampler *)jarg3;
22355   if (!argp3) {
22356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22357     return ;
22358   }
22359   arg3 = *argp3;
22360   {
22361     try {
22362       (arg1)->SetSampler(arg2,arg3);
22363     } catch (std::out_of_range& e) {
22364       {
22365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22366       };
22367     } catch (std::exception& e) {
22368       {
22369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22370       };
22371     } catch (...) {
22372       {
22373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22374       };
22375     }
22376   }
22377 }
22378
22379
22380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22381   void * jresult ;
22382   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22383   size_t arg2 ;
22384   Dali::Sampler result;
22385
22386   arg1 = (Dali::TextureSet *)jarg1;
22387   arg2 = (size_t)jarg2;
22388   {
22389     try {
22390       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22398       };
22399     } catch (...) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22402       };
22403     }
22404   }
22405   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22406   return jresult;
22407 }
22408
22409
22410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22411   unsigned long jresult ;
22412   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22413   size_t result;
22414
22415   arg1 = (Dali::TextureSet *)jarg1;
22416   {
22417     try {
22418       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22419     } catch (std::out_of_range& e) {
22420       {
22421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22422       };
22423     } catch (std::exception& e) {
22424       {
22425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22426       };
22427     } catch (...) {
22428       {
22429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22430       };
22431     }
22432   }
22433   jresult = (unsigned long)result;
22434   return jresult;
22435 }
22436
22437
22438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22439   void * jresult ;
22440   Dali::Property::Map *arg1 = 0 ;
22441   Dali::PropertyBuffer result;
22442
22443   arg1 = (Dali::Property::Map *)jarg1;
22444   if (!arg1) {
22445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22446     return 0;
22447   }
22448   {
22449     try {
22450       result = Dali::PropertyBuffer::New(*arg1);
22451     } catch (std::out_of_range& e) {
22452       {
22453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (std::exception& e) {
22456       {
22457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22466   return jresult;
22467 }
22468
22469
22470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22471   void * jresult ;
22472   Dali::PropertyBuffer *result = 0 ;
22473
22474   {
22475     try {
22476       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22477     } catch (std::out_of_range& e) {
22478       {
22479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22480       };
22481     } catch (std::exception& e) {
22482       {
22483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22484       };
22485     } catch (...) {
22486       {
22487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22488       };
22489     }
22490   }
22491   jresult = (void *)result;
22492   return jresult;
22493 }
22494
22495
22496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22497   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22498
22499   arg1 = (Dali::PropertyBuffer *)jarg1;
22500   {
22501     try {
22502       delete arg1;
22503     } catch (std::out_of_range& e) {
22504       {
22505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22506       };
22507     } catch (std::exception& e) {
22508       {
22509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22510       };
22511     } catch (...) {
22512       {
22513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22514       };
22515     }
22516   }
22517 }
22518
22519
22520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22521   void * jresult ;
22522   Dali::PropertyBuffer *arg1 = 0 ;
22523   Dali::PropertyBuffer *result = 0 ;
22524
22525   arg1 = (Dali::PropertyBuffer *)jarg1;
22526   if (!arg1) {
22527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22528     return 0;
22529   }
22530   {
22531     try {
22532       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22533     } catch (std::out_of_range& e) {
22534       {
22535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22536       };
22537     } catch (std::exception& e) {
22538       {
22539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22540       };
22541     } catch (...) {
22542       {
22543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22544       };
22545     }
22546   }
22547   jresult = (void *)result;
22548   return jresult;
22549 }
22550
22551
22552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22553   void * jresult ;
22554   Dali::BaseHandle arg1 ;
22555   Dali::BaseHandle *argp1 ;
22556   Dali::PropertyBuffer result;
22557
22558   argp1 = (Dali::BaseHandle *)jarg1;
22559   if (!argp1) {
22560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22561     return 0;
22562   }
22563   arg1 = *argp1;
22564   {
22565     try {
22566       result = Dali::PropertyBuffer::DownCast(arg1);
22567     } catch (std::out_of_range& e) {
22568       {
22569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22570       };
22571     } catch (std::exception& e) {
22572       {
22573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22574       };
22575     } catch (...) {
22576       {
22577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22578       };
22579     }
22580   }
22581   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22582   return jresult;
22583 }
22584
22585
22586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22587   void * jresult ;
22588   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22589   Dali::PropertyBuffer *arg2 = 0 ;
22590   Dali::PropertyBuffer *result = 0 ;
22591
22592   arg1 = (Dali::PropertyBuffer *)jarg1;
22593   arg2 = (Dali::PropertyBuffer *)jarg2;
22594   if (!arg2) {
22595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22596     return 0;
22597   }
22598   {
22599     try {
22600       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22601     } catch (std::out_of_range& e) {
22602       {
22603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22604       };
22605     } catch (std::exception& e) {
22606       {
22607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (...) {
22610       {
22611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22612       };
22613     }
22614   }
22615   jresult = (void *)result;
22616   return jresult;
22617 }
22618
22619
22620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22621   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22622   void *arg2 = (void *) 0 ;
22623   std::size_t arg3 ;
22624
22625   arg1 = (Dali::PropertyBuffer *)jarg1;
22626   arg2 = jarg2;
22627   arg3 = (std::size_t)jarg3;
22628   {
22629     try {
22630       (arg1)->SetData((void const *)arg2,arg3);
22631     } catch (std::out_of_range& e) {
22632       {
22633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22634       };
22635     } catch (std::exception& e) {
22636       {
22637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22638       };
22639     } catch (...) {
22640       {
22641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22642       };
22643     }
22644   }
22645 }
22646
22647
22648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22649   unsigned long jresult ;
22650   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22651   std::size_t result;
22652
22653   arg1 = (Dali::PropertyBuffer *)jarg1;
22654   {
22655     try {
22656       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22657     } catch (std::out_of_range& e) {
22658       {
22659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22660       };
22661     } catch (std::exception& e) {
22662       {
22663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (...) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22668       };
22669     }
22670   }
22671   jresult = (unsigned long)result;
22672   return jresult;
22673 }
22674
22675
22676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22677   void * jresult ;
22678   Dali::Geometry result;
22679
22680   {
22681     try {
22682       result = Dali::Geometry::New();
22683     } catch (std::out_of_range& e) {
22684       {
22685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22686       };
22687     } catch (std::exception& e) {
22688       {
22689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (...) {
22692       {
22693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22694       };
22695     }
22696   }
22697   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22698   return jresult;
22699 }
22700
22701
22702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22703   void * jresult ;
22704   Dali::Geometry *result = 0 ;
22705
22706   {
22707     try {
22708       result = (Dali::Geometry *)new Dali::Geometry();
22709     } catch (std::out_of_range& e) {
22710       {
22711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22712       };
22713     } catch (std::exception& e) {
22714       {
22715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22716       };
22717     } catch (...) {
22718       {
22719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22720       };
22721     }
22722   }
22723   jresult = (void *)result;
22724   return jresult;
22725 }
22726
22727
22728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22729   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22730
22731   arg1 = (Dali::Geometry *)jarg1;
22732   {
22733     try {
22734       delete arg1;
22735     } catch (std::out_of_range& e) {
22736       {
22737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22738       };
22739     } catch (std::exception& e) {
22740       {
22741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22742       };
22743     } catch (...) {
22744       {
22745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22746       };
22747     }
22748   }
22749 }
22750
22751
22752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22753   void * jresult ;
22754   Dali::Geometry *arg1 = 0 ;
22755   Dali::Geometry *result = 0 ;
22756
22757   arg1 = (Dali::Geometry *)jarg1;
22758   if (!arg1) {
22759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22760     return 0;
22761   }
22762   {
22763     try {
22764       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22765     } catch (std::out_of_range& e) {
22766       {
22767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22768       };
22769     } catch (std::exception& e) {
22770       {
22771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22772       };
22773     } catch (...) {
22774       {
22775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22776       };
22777     }
22778   }
22779   jresult = (void *)result;
22780   return jresult;
22781 }
22782
22783
22784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22785   void * jresult ;
22786   Dali::BaseHandle arg1 ;
22787   Dali::BaseHandle *argp1 ;
22788   Dali::Geometry result;
22789
22790   argp1 = (Dali::BaseHandle *)jarg1;
22791   if (!argp1) {
22792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22793     return 0;
22794   }
22795   arg1 = *argp1;
22796   {
22797     try {
22798       result = Dali::Geometry::DownCast(arg1);
22799     } catch (std::out_of_range& e) {
22800       {
22801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22802       };
22803     } catch (std::exception& e) {
22804       {
22805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22806       };
22807     } catch (...) {
22808       {
22809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22810       };
22811     }
22812   }
22813   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22814   return jresult;
22815 }
22816
22817
22818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22819   void * jresult ;
22820   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22821   Dali::Geometry *arg2 = 0 ;
22822   Dali::Geometry *result = 0 ;
22823
22824   arg1 = (Dali::Geometry *)jarg1;
22825   arg2 = (Dali::Geometry *)jarg2;
22826   if (!arg2) {
22827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22828     return 0;
22829   }
22830   {
22831     try {
22832       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22833     } catch (std::out_of_range& e) {
22834       {
22835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22836       };
22837     } catch (std::exception& e) {
22838       {
22839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22840       };
22841     } catch (...) {
22842       {
22843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22844       };
22845     }
22846   }
22847   jresult = (void *)result;
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22853   unsigned long jresult ;
22854   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22855   Dali::PropertyBuffer *arg2 = 0 ;
22856   std::size_t result;
22857
22858   arg1 = (Dali::Geometry *)jarg1;
22859   arg2 = (Dali::PropertyBuffer *)jarg2;
22860   if (!arg2) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22862     return 0;
22863   }
22864   {
22865     try {
22866       result = (arg1)->AddVertexBuffer(*arg2);
22867     } catch (std::out_of_range& e) {
22868       {
22869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22870       };
22871     } catch (std::exception& e) {
22872       {
22873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22874       };
22875     } catch (...) {
22876       {
22877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22878       };
22879     }
22880   }
22881   jresult = (unsigned long)result;
22882   return jresult;
22883 }
22884
22885
22886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22887   unsigned long jresult ;
22888   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22889   std::size_t result;
22890
22891   arg1 = (Dali::Geometry *)jarg1;
22892   {
22893     try {
22894       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22895     } catch (std::out_of_range& e) {
22896       {
22897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22898       };
22899     } catch (std::exception& e) {
22900       {
22901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22902       };
22903     } catch (...) {
22904       {
22905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22906       };
22907     }
22908   }
22909   jresult = (unsigned long)result;
22910   return jresult;
22911 }
22912
22913
22914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22915   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22916   std::size_t arg2 ;
22917
22918   arg1 = (Dali::Geometry *)jarg1;
22919   arg2 = (std::size_t)jarg2;
22920   {
22921     try {
22922       (arg1)->RemoveVertexBuffer(arg2);
22923     } catch (std::out_of_range& e) {
22924       {
22925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22926       };
22927     } catch (std::exception& e) {
22928       {
22929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22930       };
22931     } catch (...) {
22932       {
22933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22934       };
22935     }
22936   }
22937 }
22938
22939
22940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22941   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22942   unsigned short *arg2 = (unsigned short *) 0 ;
22943   size_t arg3 ;
22944
22945   arg1 = (Dali::Geometry *)jarg1;
22946   arg2 = jarg2;
22947   arg3 = (size_t)jarg3;
22948   {
22949     try {
22950       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22951     } catch (std::out_of_range& e) {
22952       {
22953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22954       };
22955     } catch (std::exception& e) {
22956       {
22957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22958       };
22959     } catch (...) {
22960       {
22961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22962       };
22963     }
22964   }
22965
22966
22967 }
22968
22969
22970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22971   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22972   Dali::Geometry::Type arg2 ;
22973
22974   arg1 = (Dali::Geometry *)jarg1;
22975   arg2 = (Dali::Geometry::Type)jarg2;
22976   {
22977     try {
22978       (arg1)->SetType(arg2);
22979     } catch (std::out_of_range& e) {
22980       {
22981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22982       };
22983     } catch (std::exception& e) {
22984       {
22985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22986       };
22987     } catch (...) {
22988       {
22989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22990       };
22991     }
22992   }
22993 }
22994
22995
22996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22997   int jresult ;
22998   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22999   Dali::Geometry::Type result;
23000
23001   arg1 = (Dali::Geometry *)jarg1;
23002   {
23003     try {
23004       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23005     } catch (std::out_of_range& e) {
23006       {
23007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23008       };
23009     } catch (std::exception& e) {
23010       {
23011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23012       };
23013     } catch (...) {
23014       {
23015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23016       };
23017     }
23018   }
23019   jresult = (int)result;
23020   return jresult;
23021 }
23022
23023
23024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23025   void * jresult ;
23026   Dali::Shader::Hint *result = 0 ;
23027
23028   {
23029     try {
23030       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23031     } catch (std::out_of_range& e) {
23032       {
23033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23034       };
23035     } catch (std::exception& e) {
23036       {
23037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23038       };
23039     } catch (...) {
23040       {
23041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23042       };
23043     }
23044   }
23045   jresult = (void *)result;
23046   return jresult;
23047 }
23048
23049
23050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23051   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23052
23053   arg1 = (Dali::Shader::Hint *)jarg1;
23054   {
23055     try {
23056       delete arg1;
23057     } catch (std::out_of_range& e) {
23058       {
23059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23060       };
23061     } catch (std::exception& e) {
23062       {
23063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23064       };
23065     } catch (...) {
23066       {
23067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23068       };
23069     }
23070   }
23071 }
23072
23073
23074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23075   int jresult ;
23076   int result;
23077
23078   result = (int)Dali::Shader::Property::PROGRAM;
23079   jresult = (int)result;
23080   return jresult;
23081 }
23082
23083
23084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23085   void * jresult ;
23086   Dali::Shader::Property *result = 0 ;
23087
23088   {
23089     try {
23090       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23091     } catch (std::out_of_range& e) {
23092       {
23093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23094       };
23095     } catch (std::exception& e) {
23096       {
23097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23098       };
23099     } catch (...) {
23100       {
23101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23102       };
23103     }
23104   }
23105   jresult = (void *)result;
23106   return jresult;
23107 }
23108
23109
23110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23111   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23112
23113   arg1 = (Dali::Shader::Property *)jarg1;
23114   {
23115     try {
23116       delete arg1;
23117     } catch (std::out_of_range& e) {
23118       {
23119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23120       };
23121     } catch (std::exception& e) {
23122       {
23123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23124       };
23125     } catch (...) {
23126       {
23127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23128       };
23129     }
23130   }
23131 }
23132
23133
23134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23135   void * jresult ;
23136   std::string *arg1 = 0 ;
23137   std::string *arg2 = 0 ;
23138   Dali::Shader::Hint::Value arg3 ;
23139   Dali::Shader result;
23140
23141   if (!jarg1) {
23142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23143     return 0;
23144   }
23145   std::string arg1_str(jarg1);
23146   arg1 = &arg1_str;
23147   if (!jarg2) {
23148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23149     return 0;
23150   }
23151   std::string arg2_str(jarg2);
23152   arg2 = &arg2_str;
23153   arg3 = (Dali::Shader::Hint::Value)jarg3;
23154   {
23155     try {
23156       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23157     } catch (std::out_of_range& e) {
23158       {
23159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23160       };
23161     } catch (std::exception& e) {
23162       {
23163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23164       };
23165     } catch (...) {
23166       {
23167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23168       };
23169     }
23170   }
23171   jresult = new Dali::Shader((const Dali::Shader &)result);
23172
23173   //argout typemap for const std::string&
23174
23175
23176   //argout typemap for const std::string&
23177
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23183   void * jresult ;
23184   std::string *arg1 = 0 ;
23185   std::string *arg2 = 0 ;
23186   Dali::Shader result;
23187
23188   if (!jarg1) {
23189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23190     return 0;
23191   }
23192   std::string arg1_str(jarg1);
23193   arg1 = &arg1_str;
23194   if (!jarg2) {
23195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23196     return 0;
23197   }
23198   std::string arg2_str(jarg2);
23199   arg2 = &arg2_str;
23200   {
23201     try {
23202       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23203     } catch (std::out_of_range& e) {
23204       {
23205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23206       };
23207     } catch (std::exception& e) {
23208       {
23209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23210       };
23211     } catch (...) {
23212       {
23213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23214       };
23215     }
23216   }
23217   jresult = new Dali::Shader((const Dali::Shader &)result);
23218
23219   //argout typemap for const std::string&
23220
23221
23222   //argout typemap for const std::string&
23223
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23229   void * jresult ;
23230   Dali::Shader *result = 0 ;
23231
23232   {
23233     try {
23234       result = (Dali::Shader *)new Dali::Shader();
23235     } catch (std::out_of_range& e) {
23236       {
23237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23238       };
23239     } catch (std::exception& e) {
23240       {
23241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23242       };
23243     } catch (...) {
23244       {
23245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23246       };
23247     }
23248   }
23249   jresult = (void *)result;
23250   return jresult;
23251 }
23252
23253
23254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23255   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23256
23257   arg1 = (Dali::Shader *)jarg1;
23258   {
23259     try {
23260       delete arg1;
23261     } catch (std::out_of_range& e) {
23262       {
23263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23264       };
23265     } catch (std::exception& e) {
23266       {
23267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23268       };
23269     } catch (...) {
23270       {
23271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23272       };
23273     }
23274   }
23275 }
23276
23277
23278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23279   void * jresult ;
23280   Dali::Shader *arg1 = 0 ;
23281   Dali::Shader *result = 0 ;
23282
23283   arg1 = (Dali::Shader *)jarg1;
23284   if (!arg1) {
23285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23286     return 0;
23287   }
23288   {
23289     try {
23290       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23291     } catch (std::out_of_range& e) {
23292       {
23293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23294       };
23295     } catch (std::exception& e) {
23296       {
23297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23298       };
23299     } catch (...) {
23300       {
23301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23302       };
23303     }
23304   }
23305   jresult = (void *)result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23311   void * jresult ;
23312   Dali::BaseHandle arg1 ;
23313   Dali::BaseHandle *argp1 ;
23314   Dali::Shader result;
23315
23316   argp1 = (Dali::BaseHandle *)jarg1;
23317   if (!argp1) {
23318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23319     return 0;
23320   }
23321   arg1 = *argp1;
23322   {
23323     try {
23324       result = Dali::Shader::DownCast(arg1);
23325     } catch (std::out_of_range& e) {
23326       {
23327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23328       };
23329     } catch (std::exception& e) {
23330       {
23331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23332       };
23333     } catch (...) {
23334       {
23335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23336       };
23337     }
23338   }
23339   jresult = new Dali::Shader((const Dali::Shader &)result);
23340   return jresult;
23341 }
23342
23343
23344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23345   void * jresult ;
23346   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23347   Dali::Shader *arg2 = 0 ;
23348   Dali::Shader *result = 0 ;
23349
23350   arg1 = (Dali::Shader *)jarg1;
23351   arg2 = (Dali::Shader *)jarg2;
23352   if (!arg2) {
23353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23354     return 0;
23355   }
23356   {
23357     try {
23358       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23359     } catch (std::out_of_range& e) {
23360       {
23361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23362       };
23363     } catch (std::exception& e) {
23364       {
23365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23366       };
23367     } catch (...) {
23368       {
23369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23370       };
23371     }
23372   }
23373   jresult = (void *)result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23379   int jresult ;
23380   int result;
23381
23382   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23383   jresult = (int)result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23389   int jresult ;
23390   int result;
23391
23392   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23399   int jresult ;
23400   int result;
23401
23402   result = (int)Dali::Renderer::Property::BLEND_MODE;
23403   jresult = (int)result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23409   int jresult ;
23410   int result;
23411
23412   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23413   jresult = (int)result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23419   int jresult ;
23420   int result;
23421
23422   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23423   jresult = (int)result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23429   int jresult ;
23430   int result;
23431
23432   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23433   jresult = (int)result;
23434   return jresult;
23435 }
23436
23437
23438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23439   int jresult ;
23440   int result;
23441
23442   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23443   jresult = (int)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23449   int jresult ;
23450   int result;
23451
23452   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23453   jresult = (int)result;
23454   return jresult;
23455 }
23456
23457
23458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23459   int jresult ;
23460   int result;
23461
23462   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23463   jresult = (int)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23469   int jresult ;
23470   int result;
23471
23472   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23473   jresult = (int)result;
23474   return jresult;
23475 }
23476
23477
23478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23479   int jresult ;
23480   int result;
23481
23482   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23483   jresult = (int)result;
23484   return jresult;
23485 }
23486
23487
23488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23489   int jresult ;
23490   int result;
23491
23492   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23493   jresult = (int)result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23499   int jresult ;
23500   int result;
23501
23502   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23503   jresult = (int)result;
23504   return jresult;
23505 }
23506
23507
23508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23509   int jresult ;
23510   int result;
23511
23512   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23513   jresult = (int)result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23519   int jresult ;
23520   int result;
23521
23522   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23523   jresult = (int)result;
23524   return jresult;
23525 }
23526
23527
23528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23529   int jresult ;
23530   int result;
23531
23532   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23533   jresult = (int)result;
23534   return jresult;
23535 }
23536
23537
23538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23539   int jresult ;
23540   int result;
23541
23542   result = (int)Dali::Renderer::Property::RENDER_MODE;
23543   jresult = (int)result;
23544   return jresult;
23545 }
23546
23547
23548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23549   int jresult ;
23550   int result;
23551
23552   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23553   jresult = (int)result;
23554   return jresult;
23555 }
23556
23557
23558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23559   int jresult ;
23560   int result;
23561
23562   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23563   jresult = (int)result;
23564   return jresult;
23565 }
23566
23567
23568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23569   int jresult ;
23570   int result;
23571
23572   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23573   jresult = (int)result;
23574   return jresult;
23575 }
23576
23577
23578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23579   int jresult ;
23580   int result;
23581
23582   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23583   jresult = (int)result;
23584   return jresult;
23585 }
23586
23587
23588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23589   int jresult ;
23590   int result;
23591
23592   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23593   jresult = (int)result;
23594   return jresult;
23595 }
23596
23597
23598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23599   int jresult ;
23600   int result;
23601
23602   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23603   jresult = (int)result;
23604   return jresult;
23605 }
23606
23607
23608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23609   int jresult ;
23610   int result;
23611
23612   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23613   jresult = (int)result;
23614   return jresult;
23615 }
23616
23617
23618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23619   void * jresult ;
23620   Dali::Renderer::Property *result = 0 ;
23621
23622   {
23623     try {
23624       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23625     } catch (std::out_of_range& e) {
23626       {
23627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23628       };
23629     } catch (std::exception& e) {
23630       {
23631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23632       };
23633     } catch (...) {
23634       {
23635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23636       };
23637     }
23638   }
23639   jresult = (void *)result;
23640   return jresult;
23641 }
23642
23643
23644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23645   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23646
23647   arg1 = (Dali::Renderer::Property *)jarg1;
23648   {
23649     try {
23650       delete arg1;
23651     } catch (std::out_of_range& e) {
23652       {
23653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23654       };
23655     } catch (std::exception& e) {
23656       {
23657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23658       };
23659     } catch (...) {
23660       {
23661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23662       };
23663     }
23664   }
23665 }
23666
23667
23668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23669   void * jresult ;
23670   Dali::Geometry *arg1 = 0 ;
23671   Dali::Shader *arg2 = 0 ;
23672   Dali::Renderer result;
23673
23674   arg1 = (Dali::Geometry *)jarg1;
23675   if (!arg1) {
23676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23677     return 0;
23678   }
23679   arg2 = (Dali::Shader *)jarg2;
23680   if (!arg2) {
23681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23682     return 0;
23683   }
23684   {
23685     try {
23686       result = Dali::Renderer::New(*arg1,*arg2);
23687     } catch (std::out_of_range& e) {
23688       {
23689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23690       };
23691     } catch (std::exception& e) {
23692       {
23693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23694       };
23695     } catch (...) {
23696       {
23697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23698       };
23699     }
23700   }
23701   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23702   return jresult;
23703 }
23704
23705
23706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23707   void * jresult ;
23708   Dali::Renderer *result = 0 ;
23709
23710   {
23711     try {
23712       result = (Dali::Renderer *)new Dali::Renderer();
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23720       };
23721     } catch (...) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23724       };
23725     }
23726   }
23727   jresult = (void *)result;
23728   return jresult;
23729 }
23730
23731
23732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23733   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23734
23735   arg1 = (Dali::Renderer *)jarg1;
23736   {
23737     try {
23738       delete arg1;
23739     } catch (std::out_of_range& e) {
23740       {
23741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23742       };
23743     } catch (std::exception& e) {
23744       {
23745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23746       };
23747     } catch (...) {
23748       {
23749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23750       };
23751     }
23752   }
23753 }
23754
23755
23756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23757   void * jresult ;
23758   Dali::Renderer *arg1 = 0 ;
23759   Dali::Renderer *result = 0 ;
23760
23761   arg1 = (Dali::Renderer *)jarg1;
23762   if (!arg1) {
23763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23764     return 0;
23765   }
23766   {
23767     try {
23768       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23769     } catch (std::out_of_range& e) {
23770       {
23771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23772       };
23773     } catch (std::exception& e) {
23774       {
23775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23776       };
23777     } catch (...) {
23778       {
23779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23780       };
23781     }
23782   }
23783   jresult = (void *)result;
23784   return jresult;
23785 }
23786
23787
23788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23789   void * jresult ;
23790   Dali::BaseHandle arg1 ;
23791   Dali::BaseHandle *argp1 ;
23792   Dali::Renderer result;
23793
23794   argp1 = (Dali::BaseHandle *)jarg1;
23795   if (!argp1) {
23796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23797     return 0;
23798   }
23799   arg1 = *argp1;
23800   {
23801     try {
23802       result = Dali::Renderer::DownCast(arg1);
23803     } catch (std::out_of_range& e) {
23804       {
23805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23806       };
23807     } catch (std::exception& e) {
23808       {
23809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23810       };
23811     } catch (...) {
23812       {
23813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23814       };
23815     }
23816   }
23817   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23818   return jresult;
23819 }
23820
23821
23822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23823   void * jresult ;
23824   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23825   Dali::Renderer *arg2 = 0 ;
23826   Dali::Renderer *result = 0 ;
23827
23828   arg1 = (Dali::Renderer *)jarg1;
23829   arg2 = (Dali::Renderer *)jarg2;
23830   if (!arg2) {
23831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23832     return 0;
23833   }
23834   {
23835     try {
23836       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23837     } catch (std::out_of_range& e) {
23838       {
23839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23840       };
23841     } catch (std::exception& e) {
23842       {
23843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23844       };
23845     } catch (...) {
23846       {
23847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23848       };
23849     }
23850   }
23851   jresult = (void *)result;
23852   return jresult;
23853 }
23854
23855
23856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23857   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23858   Dali::Geometry *arg2 = 0 ;
23859
23860   arg1 = (Dali::Renderer *)jarg1;
23861   arg2 = (Dali::Geometry *)jarg2;
23862   if (!arg2) {
23863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23864     return ;
23865   }
23866   {
23867     try {
23868       (arg1)->SetGeometry(*arg2);
23869     } catch (std::out_of_range& e) {
23870       {
23871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23872       };
23873     } catch (std::exception& e) {
23874       {
23875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23880       };
23881     }
23882   }
23883 }
23884
23885
23886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23887   void * jresult ;
23888   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23889   Dali::Geometry result;
23890
23891   arg1 = (Dali::Renderer *)jarg1;
23892   {
23893     try {
23894       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23895     } catch (std::out_of_range& e) {
23896       {
23897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (std::exception& e) {
23900       {
23901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (...) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23906       };
23907     }
23908   }
23909   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23910   return jresult;
23911 }
23912
23913
23914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23915   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23916   int arg2 ;
23917   int arg3 ;
23918
23919   arg1 = (Dali::Renderer *)jarg1;
23920   arg2 = (int)jarg2;
23921   arg3 = (int)jarg3;
23922   {
23923     try {
23924       (arg1)->SetIndexRange(arg2,arg3);
23925     } catch (std::out_of_range& e) {
23926       {
23927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23928       };
23929     } catch (std::exception& e) {
23930       {
23931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23932       };
23933     } catch (...) {
23934       {
23935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23936       };
23937     }
23938   }
23939 }
23940
23941
23942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23943   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23944   Dali::TextureSet *arg2 = 0 ;
23945
23946   arg1 = (Dali::Renderer *)jarg1;
23947   arg2 = (Dali::TextureSet *)jarg2;
23948   if (!arg2) {
23949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23950     return ;
23951   }
23952   {
23953     try {
23954       (arg1)->SetTextures(*arg2);
23955     } catch (std::out_of_range& e) {
23956       {
23957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23958       };
23959     } catch (std::exception& e) {
23960       {
23961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23962       };
23963     } catch (...) {
23964       {
23965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23966       };
23967     }
23968   }
23969 }
23970
23971
23972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23973   void * jresult ;
23974   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23975   Dali::TextureSet result;
23976
23977   arg1 = (Dali::Renderer *)jarg1;
23978   {
23979     try {
23980       result = ((Dali::Renderer const *)arg1)->GetTextures();
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (...) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23992       };
23993     }
23994   }
23995   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23996   return jresult;
23997 }
23998
23999
24000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24001   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24002   Dali::Shader *arg2 = 0 ;
24003
24004   arg1 = (Dali::Renderer *)jarg1;
24005   arg2 = (Dali::Shader *)jarg2;
24006   if (!arg2) {
24007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24008     return ;
24009   }
24010   {
24011     try {
24012       (arg1)->SetShader(*arg2);
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24020       };
24021     } catch (...) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24024       };
24025     }
24026   }
24027 }
24028
24029
24030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24031   void * jresult ;
24032   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24033   Dali::Shader result;
24034
24035   arg1 = (Dali::Renderer *)jarg1;
24036   {
24037     try {
24038       result = ((Dali::Renderer const *)arg1)->GetShader();
24039     } catch (std::out_of_range& e) {
24040       {
24041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24042       };
24043     } catch (std::exception& e) {
24044       {
24045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24046       };
24047     } catch (...) {
24048       {
24049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24050       };
24051     }
24052   }
24053   jresult = new Dali::Shader((const Dali::Shader &)result);
24054   return jresult;
24055 }
24056
24057
24058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24059   void * jresult ;
24060   Dali::FrameBuffer::Attachment *result = 0 ;
24061
24062   {
24063     try {
24064       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24065     } catch (std::out_of_range& e) {
24066       {
24067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24068       };
24069     } catch (std::exception& e) {
24070       {
24071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24072       };
24073     } catch (...) {
24074       {
24075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24076       };
24077     }
24078   }
24079   jresult = (void *)result;
24080   return jresult;
24081 }
24082
24083
24084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24085   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24086
24087   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24088   {
24089     try {
24090       delete arg1;
24091     } catch (std::out_of_range& e) {
24092       {
24093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24094       };
24095     } catch (std::exception& e) {
24096       {
24097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24098       };
24099     } catch (...) {
24100       {
24101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24102       };
24103     }
24104   }
24105 }
24106
24107
24108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24109   void * jresult ;
24110   unsigned int arg1 ;
24111   unsigned int arg2 ;
24112   unsigned int arg3 ;
24113   Dali::FrameBuffer result;
24114
24115   arg1 = (unsigned int)jarg1;
24116   arg2 = (unsigned int)jarg2;
24117   arg3 = (unsigned int)jarg3;
24118   {
24119     try {
24120       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24121     } catch (std::out_of_range& e) {
24122       {
24123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24124       };
24125     } catch (std::exception& e) {
24126       {
24127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24128       };
24129     } catch (...) {
24130       {
24131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24132       };
24133     }
24134   }
24135   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24136   return jresult;
24137 }
24138
24139
24140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24141   void * jresult ;
24142   Dali::FrameBuffer *result = 0 ;
24143
24144   {
24145     try {
24146       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24147     } catch (std::out_of_range& e) {
24148       {
24149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24150       };
24151     } catch (std::exception& e) {
24152       {
24153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (...) {
24156       {
24157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24158       };
24159     }
24160   }
24161   jresult = (void *)result;
24162   return jresult;
24163 }
24164
24165
24166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24167   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24168
24169   arg1 = (Dali::FrameBuffer *)jarg1;
24170   {
24171     try {
24172       delete arg1;
24173     } catch (std::out_of_range& e) {
24174       {
24175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24176       };
24177     } catch (std::exception& e) {
24178       {
24179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24180       };
24181     } catch (...) {
24182       {
24183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24184       };
24185     }
24186   }
24187 }
24188
24189
24190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24191   void * jresult ;
24192   Dali::FrameBuffer *arg1 = 0 ;
24193   Dali::FrameBuffer *result = 0 ;
24194
24195   arg1 = (Dali::FrameBuffer *)jarg1;
24196   if (!arg1) {
24197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24198     return 0;
24199   }
24200   {
24201     try {
24202       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24203     } catch (std::out_of_range& e) {
24204       {
24205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24206       };
24207     } catch (std::exception& e) {
24208       {
24209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24210       };
24211     } catch (...) {
24212       {
24213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24214       };
24215     }
24216   }
24217   jresult = (void *)result;
24218   return jresult;
24219 }
24220
24221
24222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24223   void * jresult ;
24224   Dali::BaseHandle arg1 ;
24225   Dali::BaseHandle *argp1 ;
24226   Dali::FrameBuffer result;
24227
24228   argp1 = (Dali::BaseHandle *)jarg1;
24229   if (!argp1) {
24230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24231     return 0;
24232   }
24233   arg1 = *argp1;
24234   {
24235     try {
24236       result = Dali::FrameBuffer::DownCast(arg1);
24237     } catch (std::out_of_range& e) {
24238       {
24239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24240       };
24241     } catch (std::exception& e) {
24242       {
24243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24244       };
24245     } catch (...) {
24246       {
24247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24248       };
24249     }
24250   }
24251   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24252   return jresult;
24253 }
24254
24255
24256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24257   void * jresult ;
24258   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24259   Dali::FrameBuffer *arg2 = 0 ;
24260   Dali::FrameBuffer *result = 0 ;
24261
24262   arg1 = (Dali::FrameBuffer *)jarg1;
24263   arg2 = (Dali::FrameBuffer *)jarg2;
24264   if (!arg2) {
24265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24266     return 0;
24267   }
24268   {
24269     try {
24270       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24271     } catch (std::out_of_range& e) {
24272       {
24273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24274       };
24275     } catch (std::exception& e) {
24276       {
24277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24278       };
24279     } catch (...) {
24280       {
24281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24282       };
24283     }
24284   }
24285   jresult = (void *)result;
24286   return jresult;
24287 }
24288
24289
24290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24291   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24292   Dali::Texture *arg2 = 0 ;
24293
24294   arg1 = (Dali::FrameBuffer *)jarg1;
24295   arg2 = (Dali::Texture *)jarg2;
24296   if (!arg2) {
24297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24298     return ;
24299   }
24300   {
24301     try {
24302       (arg1)->AttachColorTexture(*arg2);
24303     } catch (std::out_of_range& e) {
24304       {
24305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24306       };
24307     } catch (std::exception& e) {
24308       {
24309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24310       };
24311     } catch (...) {
24312       {
24313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24314       };
24315     }
24316   }
24317 }
24318
24319
24320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24321   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24322   Dali::Texture *arg2 = 0 ;
24323   unsigned int arg3 ;
24324   unsigned int arg4 ;
24325
24326   arg1 = (Dali::FrameBuffer *)jarg1;
24327   arg2 = (Dali::Texture *)jarg2;
24328   if (!arg2) {
24329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24330     return ;
24331   }
24332   arg3 = (unsigned int)jarg3;
24333   arg4 = (unsigned int)jarg4;
24334   {
24335     try {
24336       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24337     } catch (std::out_of_range& e) {
24338       {
24339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24340       };
24341     } catch (std::exception& e) {
24342       {
24343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24344       };
24345     } catch (...) {
24346       {
24347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24348       };
24349     }
24350   }
24351 }
24352
24353
24354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24355   void * jresult ;
24356   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24357   Dali::Texture result;
24358
24359   arg1 = (Dali::FrameBuffer *)jarg1;
24360   {
24361     try {
24362       result = (arg1)->GetColorTexture();
24363     } catch (std::out_of_range& e) {
24364       {
24365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24366       };
24367     } catch (std::exception& e) {
24368       {
24369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24370       };
24371     } catch (...) {
24372       {
24373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24374       };
24375     }
24376   }
24377   jresult = new Dali::Texture((const Dali::Texture &)result);
24378   return jresult;
24379 }
24380
24381
24382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24383   void * jresult ;
24384   Dali::RenderTaskList *result = 0 ;
24385
24386   {
24387     try {
24388       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24389     } catch (std::out_of_range& e) {
24390       {
24391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (std::exception& e) {
24394       {
24395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24396       };
24397     } catch (...) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24400       };
24401     }
24402   }
24403   jresult = (void *)result;
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24409   void * jresult ;
24410   Dali::BaseHandle arg1 ;
24411   Dali::BaseHandle *argp1 ;
24412   Dali::RenderTaskList result;
24413
24414   argp1 = (Dali::BaseHandle *)jarg1;
24415   if (!argp1) {
24416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24417     return 0;
24418   }
24419   arg1 = *argp1;
24420   {
24421     try {
24422       result = Dali::RenderTaskList::DownCast(arg1);
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 (...) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24434       };
24435     }
24436   }
24437   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24438   return jresult;
24439 }
24440
24441
24442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24443   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24444
24445   arg1 = (Dali::RenderTaskList *)jarg1;
24446   {
24447     try {
24448       delete arg1;
24449     } catch (std::out_of_range& e) {
24450       {
24451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24452       };
24453     } catch (std::exception& e) {
24454       {
24455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24456       };
24457     } catch (...) {
24458       {
24459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24460       };
24461     }
24462   }
24463 }
24464
24465
24466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24467   void * jresult ;
24468   Dali::RenderTaskList *arg1 = 0 ;
24469   Dali::RenderTaskList *result = 0 ;
24470
24471   arg1 = (Dali::RenderTaskList *)jarg1;
24472   if (!arg1) {
24473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24474     return 0;
24475   }
24476   {
24477     try {
24478       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24479     } catch (std::out_of_range& e) {
24480       {
24481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24482       };
24483     } catch (std::exception& e) {
24484       {
24485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24486       };
24487     } catch (...) {
24488       {
24489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24490       };
24491     }
24492   }
24493   jresult = (void *)result;
24494   return jresult;
24495 }
24496
24497
24498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24499   void * jresult ;
24500   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24501   Dali::RenderTaskList *arg2 = 0 ;
24502   Dali::RenderTaskList *result = 0 ;
24503
24504   arg1 = (Dali::RenderTaskList *)jarg1;
24505   arg2 = (Dali::RenderTaskList *)jarg2;
24506   if (!arg2) {
24507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24508     return 0;
24509   }
24510   {
24511     try {
24512       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24513     } catch (std::out_of_range& e) {
24514       {
24515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24516       };
24517     } catch (std::exception& e) {
24518       {
24519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24520       };
24521     } catch (...) {
24522       {
24523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24524       };
24525     }
24526   }
24527   jresult = (void *)result;
24528   return jresult;
24529 }
24530
24531
24532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24533   void * jresult ;
24534   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24535   Dali::RenderTask result;
24536
24537   arg1 = (Dali::RenderTaskList *)jarg1;
24538   {
24539     try {
24540       result = (arg1)->CreateTask();
24541     } catch (std::out_of_range& e) {
24542       {
24543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24544       };
24545     } catch (std::exception& e) {
24546       {
24547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24548       };
24549     } catch (...) {
24550       {
24551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24552       };
24553     }
24554   }
24555   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24556   return jresult;
24557 }
24558
24559
24560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24561   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24562   Dali::RenderTask arg2 ;
24563   Dali::RenderTask *argp2 ;
24564
24565   arg1 = (Dali::RenderTaskList *)jarg1;
24566   argp2 = (Dali::RenderTask *)jarg2;
24567   if (!argp2) {
24568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24569     return ;
24570   }
24571   arg2 = *argp2;
24572   {
24573     try {
24574       (arg1)->RemoveTask(arg2);
24575     } catch (std::out_of_range& e) {
24576       {
24577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24578       };
24579     } catch (std::exception& e) {
24580       {
24581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24582       };
24583     } catch (...) {
24584       {
24585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24586       };
24587     }
24588   }
24589 }
24590
24591
24592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24593   unsigned int jresult ;
24594   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24595   unsigned int result;
24596
24597   arg1 = (Dali::RenderTaskList *)jarg1;
24598   {
24599     try {
24600       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24601     } catch (std::out_of_range& e) {
24602       {
24603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24604       };
24605     } catch (std::exception& e) {
24606       {
24607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24608       };
24609     } catch (...) {
24610       {
24611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24612       };
24613     }
24614   }
24615   jresult = result;
24616   return jresult;
24617 }
24618
24619
24620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24621   void * jresult ;
24622   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24623   unsigned int arg2 ;
24624   Dali::RenderTask result;
24625
24626   arg1 = (Dali::RenderTaskList *)jarg1;
24627   arg2 = (unsigned int)jarg2;
24628   {
24629     try {
24630       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24631     } catch (std::out_of_range& e) {
24632       {
24633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24634       };
24635     } catch (std::exception& e) {
24636       {
24637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24638       };
24639     } catch (...) {
24640       {
24641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24642       };
24643     }
24644   }
24645   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24651   int jresult ;
24652   int result;
24653
24654   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24655   jresult = (int)result;
24656   return jresult;
24657 }
24658
24659
24660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24661   int jresult ;
24662   int result;
24663
24664   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24665   jresult = (int)result;
24666   return jresult;
24667 }
24668
24669
24670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24671   int jresult ;
24672   int result;
24673
24674   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24675   jresult = (int)result;
24676   return jresult;
24677 }
24678
24679
24680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24681   int jresult ;
24682   int result;
24683
24684   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24685   jresult = (int)result;
24686   return jresult;
24687 }
24688
24689
24690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24691   void * jresult ;
24692   Dali::RenderTask::Property *result = 0 ;
24693
24694   {
24695     try {
24696       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24697     } catch (std::out_of_range& e) {
24698       {
24699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24700       };
24701     } catch (std::exception& e) {
24702       {
24703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24704       };
24705     } catch (...) {
24706       {
24707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24708       };
24709     }
24710   }
24711   jresult = (void *)result;
24712   return jresult;
24713 }
24714
24715
24716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24717   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24718
24719   arg1 = (Dali::RenderTask::Property *)jarg1;
24720   {
24721     try {
24722       delete arg1;
24723     } catch (std::out_of_range& e) {
24724       {
24725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24726       };
24727     } catch (std::exception& e) {
24728       {
24729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24730       };
24731     } catch (...) {
24732       {
24733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24734       };
24735     }
24736   }
24737 }
24738
24739
24740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24741   void * jresult ;
24742   bool (*result)(Dali::Vector2 &) = 0 ;
24743
24744   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24745   jresult = (void *)result;
24746   return jresult;
24747 }
24748
24749
24750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24751   void * jresult ;
24752   bool (*result)(Dali::Vector2 &) = 0 ;
24753
24754   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24755   jresult = (void *)result;
24756   return jresult;
24757 }
24758
24759
24760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24761   unsigned int jresult ;
24762   bool result;
24763
24764   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24765   jresult = result;
24766   return jresult;
24767 }
24768
24769
24770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24771   unsigned int jresult ;
24772   bool result;
24773
24774   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24775   jresult = result;
24776   return jresult;
24777 }
24778
24779
24780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24781   void * jresult ;
24782   Dali::Vector4 *result = 0 ;
24783
24784   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24785   jresult = (void *)result;
24786   return jresult;
24787 }
24788
24789
24790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24791   unsigned int jresult ;
24792   bool result;
24793
24794   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24795   jresult = result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24801   unsigned int jresult ;
24802   bool result;
24803
24804   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24805   jresult = result;
24806   return jresult;
24807 }
24808
24809
24810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24811   unsigned int jresult ;
24812   unsigned int result;
24813
24814   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24815   jresult = result;
24816   return jresult;
24817 }
24818
24819
24820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24821   void * jresult ;
24822   Dali::RenderTask *result = 0 ;
24823
24824   {
24825     try {
24826       result = (Dali::RenderTask *)new Dali::RenderTask();
24827     } catch (std::out_of_range& e) {
24828       {
24829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24830       };
24831     } catch (std::exception& e) {
24832       {
24833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24834       };
24835     } catch (...) {
24836       {
24837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24838       };
24839     }
24840   }
24841   jresult = (void *)result;
24842   return jresult;
24843 }
24844
24845
24846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24847   void * jresult ;
24848   Dali::BaseHandle arg1 ;
24849   Dali::BaseHandle *argp1 ;
24850   Dali::RenderTask result;
24851
24852   argp1 = (Dali::BaseHandle *)jarg1;
24853   if (!argp1) {
24854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24855     return 0;
24856   }
24857   arg1 = *argp1;
24858   {
24859     try {
24860       result = Dali::RenderTask::DownCast(arg1);
24861     } catch (std::out_of_range& e) {
24862       {
24863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24864       };
24865     } catch (std::exception& e) {
24866       {
24867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24868       };
24869     } catch (...) {
24870       {
24871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24872       };
24873     }
24874   }
24875   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24876   return jresult;
24877 }
24878
24879
24880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24881   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24882
24883   arg1 = (Dali::RenderTask *)jarg1;
24884   {
24885     try {
24886       delete arg1;
24887     } catch (std::out_of_range& e) {
24888       {
24889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24890       };
24891     } catch (std::exception& e) {
24892       {
24893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24894       };
24895     } catch (...) {
24896       {
24897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24898       };
24899     }
24900   }
24901 }
24902
24903
24904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24905   void * jresult ;
24906   Dali::RenderTask *arg1 = 0 ;
24907   Dali::RenderTask *result = 0 ;
24908
24909   arg1 = (Dali::RenderTask *)jarg1;
24910   if (!arg1) {
24911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24912     return 0;
24913   }
24914   {
24915     try {
24916       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24917     } catch (std::out_of_range& e) {
24918       {
24919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24920       };
24921     } catch (std::exception& e) {
24922       {
24923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24924       };
24925     } catch (...) {
24926       {
24927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24928       };
24929     }
24930   }
24931   jresult = (void *)result;
24932   return jresult;
24933 }
24934
24935
24936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24937   void * jresult ;
24938   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24939   Dali::RenderTask *arg2 = 0 ;
24940   Dali::RenderTask *result = 0 ;
24941
24942   arg1 = (Dali::RenderTask *)jarg1;
24943   arg2 = (Dali::RenderTask *)jarg2;
24944   if (!arg2) {
24945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24946     return 0;
24947   }
24948   {
24949     try {
24950       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24951     } catch (std::out_of_range& e) {
24952       {
24953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24954       };
24955     } catch (std::exception& e) {
24956       {
24957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24958       };
24959     } catch (...) {
24960       {
24961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24962       };
24963     }
24964   }
24965   jresult = (void *)result;
24966   return jresult;
24967 }
24968
24969
24970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24972   Dali::Actor arg2 ;
24973   Dali::Actor *argp2 ;
24974
24975   arg1 = (Dali::RenderTask *)jarg1;
24976   argp2 = (Dali::Actor *)jarg2;
24977   if (!argp2) {
24978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24979     return ;
24980   }
24981   arg2 = *argp2;
24982   {
24983     try {
24984       (arg1)->SetSourceActor(arg2);
24985     } catch (std::out_of_range& e) {
24986       {
24987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24988       };
24989     } catch (std::exception& e) {
24990       {
24991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24992       };
24993     } catch (...) {
24994       {
24995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24996       };
24997     }
24998   }
24999 }
25000
25001
25002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25003   void * jresult ;
25004   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25005   Dali::Actor result;
25006
25007   arg1 = (Dali::RenderTask *)jarg1;
25008   {
25009     try {
25010       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25011     } catch (std::out_of_range& e) {
25012       {
25013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25014       };
25015     } catch (std::exception& e) {
25016       {
25017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25018       };
25019     } catch (...) {
25020       {
25021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25022       };
25023     }
25024   }
25025   jresult = new Dali::Actor((const Dali::Actor &)result);
25026   return jresult;
25027 }
25028
25029
25030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25032   bool arg2 ;
25033
25034   arg1 = (Dali::RenderTask *)jarg1;
25035   arg2 = jarg2 ? true : false;
25036   {
25037     try {
25038       (arg1)->SetExclusive(arg2);
25039     } catch (std::out_of_range& e) {
25040       {
25041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25042       };
25043     } catch (std::exception& e) {
25044       {
25045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25046       };
25047     } catch (...) {
25048       {
25049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25050       };
25051     }
25052   }
25053 }
25054
25055
25056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25057   unsigned int jresult ;
25058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25059   bool result;
25060
25061   arg1 = (Dali::RenderTask *)jarg1;
25062   {
25063     try {
25064       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25065     } catch (std::out_of_range& e) {
25066       {
25067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25068       };
25069     } catch (std::exception& e) {
25070       {
25071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25072       };
25073     } catch (...) {
25074       {
25075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25076       };
25077     }
25078   }
25079   jresult = result;
25080   return jresult;
25081 }
25082
25083
25084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25085   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25086   bool arg2 ;
25087
25088   arg1 = (Dali::RenderTask *)jarg1;
25089   arg2 = jarg2 ? true : false;
25090   {
25091     try {
25092       (arg1)->SetInputEnabled(arg2);
25093     } catch (std::out_of_range& e) {
25094       {
25095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25096       };
25097     } catch (std::exception& e) {
25098       {
25099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25100       };
25101     } catch (...) {
25102       {
25103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25104       };
25105     }
25106   }
25107 }
25108
25109
25110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25111   unsigned int jresult ;
25112   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25113   bool result;
25114
25115   arg1 = (Dali::RenderTask *)jarg1;
25116   {
25117     try {
25118       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
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 (...) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25130       };
25131     }
25132   }
25133   jresult = result;
25134   return jresult;
25135 }
25136
25137
25138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25139   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25140   Dali::CameraActor arg2 ;
25141   Dali::CameraActor *argp2 ;
25142
25143   arg1 = (Dali::RenderTask *)jarg1;
25144   argp2 = (Dali::CameraActor *)jarg2;
25145   if (!argp2) {
25146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25147     return ;
25148   }
25149   arg2 = *argp2;
25150   {
25151     try {
25152       (arg1)->SetCameraActor(arg2);
25153     } catch (std::out_of_range& e) {
25154       {
25155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25156       };
25157     } catch (std::exception& e) {
25158       {
25159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25160       };
25161     } catch (...) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25164       };
25165     }
25166   }
25167 }
25168
25169
25170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25171   void * jresult ;
25172   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25173   Dali::CameraActor result;
25174
25175   arg1 = (Dali::RenderTask *)jarg1;
25176   {
25177     try {
25178       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25179     } catch (std::out_of_range& e) {
25180       {
25181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25182       };
25183     } catch (std::exception& e) {
25184       {
25185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25186       };
25187     } catch (...) {
25188       {
25189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25190       };
25191     }
25192   }
25193   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25194   return jresult;
25195 }
25196
25197
25198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25199   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25200   Dali::FrameBufferImage arg2 ;
25201   Dali::FrameBufferImage *argp2 ;
25202
25203   arg1 = (Dali::RenderTask *)jarg1;
25204   argp2 = (Dali::FrameBufferImage *)jarg2;
25205   if (!argp2) {
25206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25207     return ;
25208   }
25209   arg2 = *argp2;
25210   {
25211     try {
25212       (arg1)->SetTargetFrameBuffer(arg2);
25213     } catch (std::out_of_range& e) {
25214       {
25215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25216       };
25217     } catch (std::exception& e) {
25218       {
25219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25220       };
25221     } catch (...) {
25222       {
25223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25224       };
25225     }
25226   }
25227 }
25228
25229
25230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25231   void * jresult ;
25232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25233   Dali::FrameBufferImage result;
25234
25235   arg1 = (Dali::RenderTask *)jarg1;
25236   {
25237     try {
25238       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25239     } catch (std::out_of_range& e) {
25240       {
25241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25242       };
25243     } catch (std::exception& e) {
25244       {
25245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25246       };
25247     } catch (...) {
25248       {
25249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25250       };
25251     }
25252   }
25253   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25254   return jresult;
25255 }
25256
25257
25258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25259   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25260   Dali::FrameBuffer arg2 ;
25261   Dali::FrameBuffer *argp2 ;
25262
25263   arg1 = (Dali::RenderTask *)jarg1;
25264   argp2 = (Dali::FrameBuffer *)jarg2;
25265   if (!argp2) {
25266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25267     return ;
25268   }
25269   arg2 = *argp2;
25270   {
25271     try {
25272       (arg1)->SetFrameBuffer(arg2);
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 (...) {
25282       {
25283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25284       };
25285     }
25286   }
25287 }
25288
25289
25290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25291   void * jresult ;
25292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25293   Dali::FrameBuffer result;
25294
25295   arg1 = (Dali::RenderTask *)jarg1;
25296   {
25297     try {
25298       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25299     } catch (std::out_of_range& e) {
25300       {
25301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25302       };
25303     } catch (std::exception& e) {
25304       {
25305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25306       };
25307     } catch (...) {
25308       {
25309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25310       };
25311     }
25312   }
25313   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25314   return jresult;
25315 }
25316
25317
25318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25319   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25320   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25321
25322   arg1 = (Dali::RenderTask *)jarg1;
25323   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25324   {
25325     try {
25326       (arg1)->SetScreenToFrameBufferFunction(arg2);
25327     } catch (std::out_of_range& e) {
25328       {
25329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25330       };
25331     } catch (std::exception& e) {
25332       {
25333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25334       };
25335     } catch (...) {
25336       {
25337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25338       };
25339     }
25340   }
25341 }
25342
25343
25344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25345   void * jresult ;
25346   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25347   Dali::RenderTask::ScreenToFrameBufferFunction result;
25348
25349   arg1 = (Dali::RenderTask *)jarg1;
25350   {
25351     try {
25352       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25353     } catch (std::out_of_range& e) {
25354       {
25355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25356       };
25357     } catch (std::exception& e) {
25358       {
25359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25360       };
25361     } catch (...) {
25362       {
25363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25364       };
25365     }
25366   }
25367   jresult = (void *)result;
25368   return jresult;
25369 }
25370
25371
25372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25373   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25374   Dali::Actor arg2 ;
25375   Dali::Actor *argp2 ;
25376
25377   arg1 = (Dali::RenderTask *)jarg1;
25378   argp2 = (Dali::Actor *)jarg2;
25379   if (!argp2) {
25380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25381     return ;
25382   }
25383   arg2 = *argp2;
25384   {
25385     try {
25386       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25387     } catch (std::out_of_range& e) {
25388       {
25389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25390       };
25391     } catch (std::exception& e) {
25392       {
25393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25394       };
25395     } catch (...) {
25396       {
25397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25398       };
25399     }
25400   }
25401 }
25402
25403
25404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25405   void * jresult ;
25406   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25407   Dali::Actor result;
25408
25409   arg1 = (Dali::RenderTask *)jarg1;
25410   {
25411     try {
25412       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25413     } catch (std::out_of_range& e) {
25414       {
25415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25416       };
25417     } catch (std::exception& e) {
25418       {
25419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25420       };
25421     } catch (...) {
25422       {
25423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25424       };
25425     }
25426   }
25427   jresult = new Dali::Actor((const Dali::Actor &)result);
25428   return jresult;
25429 }
25430
25431
25432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25433   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25434   Dali::Vector2 arg2 ;
25435   Dali::Vector2 *argp2 ;
25436
25437   arg1 = (Dali::RenderTask *)jarg1;
25438   argp2 = (Dali::Vector2 *)jarg2;
25439   if (!argp2) {
25440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25441     return ;
25442   }
25443   arg2 = *argp2;
25444   {
25445     try {
25446       (arg1)->SetViewportPosition(arg2);
25447     } catch (std::out_of_range& e) {
25448       {
25449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25450       };
25451     } catch (std::exception& e) {
25452       {
25453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25454       };
25455     } catch (...) {
25456       {
25457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25458       };
25459     }
25460   }
25461 }
25462
25463
25464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25465   void * jresult ;
25466   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25467   Dali::Vector2 result;
25468
25469   arg1 = (Dali::RenderTask *)jarg1;
25470   {
25471     try {
25472       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
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 (...) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25484       };
25485     }
25486   }
25487   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25488   return jresult;
25489 }
25490
25491
25492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25494   Dali::Vector2 arg2 ;
25495   Dali::Vector2 *argp2 ;
25496
25497   arg1 = (Dali::RenderTask *)jarg1;
25498   argp2 = (Dali::Vector2 *)jarg2;
25499   if (!argp2) {
25500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25501     return ;
25502   }
25503   arg2 = *argp2;
25504   {
25505     try {
25506       (arg1)->SetViewportSize(arg2);
25507     } catch (std::out_of_range& e) {
25508       {
25509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25510       };
25511     } catch (std::exception& e) {
25512       {
25513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (...) {
25516       {
25517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25518       };
25519     }
25520   }
25521 }
25522
25523
25524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25525   void * jresult ;
25526   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25527   Dali::Vector2 result;
25528
25529   arg1 = (Dali::RenderTask *)jarg1;
25530   {
25531     try {
25532       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25533     } catch (std::out_of_range& e) {
25534       {
25535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25536       };
25537     } catch (std::exception& e) {
25538       {
25539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25540       };
25541     } catch (...) {
25542       {
25543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25544       };
25545     }
25546   }
25547   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25548   return jresult;
25549 }
25550
25551
25552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25553   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25554   Dali::Viewport arg2 ;
25555   Dali::Viewport *argp2 ;
25556
25557   arg1 = (Dali::RenderTask *)jarg1;
25558   argp2 = (Dali::Viewport *)jarg2;
25559   if (!argp2) {
25560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25561     return ;
25562   }
25563   arg2 = *argp2;
25564   {
25565     try {
25566       (arg1)->SetViewport(arg2);
25567     } catch (std::out_of_range& e) {
25568       {
25569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25570       };
25571     } catch (std::exception& e) {
25572       {
25573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25574       };
25575     } catch (...) {
25576       {
25577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25578       };
25579     }
25580   }
25581 }
25582
25583
25584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25585   void * jresult ;
25586   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25587   Dali::Viewport result;
25588
25589   arg1 = (Dali::RenderTask *)jarg1;
25590   {
25591     try {
25592       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25593     } catch (std::out_of_range& e) {
25594       {
25595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25596       };
25597     } catch (std::exception& e) {
25598       {
25599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25600       };
25601     } catch (...) {
25602       {
25603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25604       };
25605     }
25606   }
25607   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25613   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25614   Dali::Vector4 *arg2 = 0 ;
25615
25616   arg1 = (Dali::RenderTask *)jarg1;
25617   arg2 = (Dali::Vector4 *)jarg2;
25618   if (!arg2) {
25619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25620     return ;
25621   }
25622   {
25623     try {
25624       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25625     } catch (std::out_of_range& e) {
25626       {
25627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25628       };
25629     } catch (std::exception& e) {
25630       {
25631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25632       };
25633     } catch (...) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25636       };
25637     }
25638   }
25639 }
25640
25641
25642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25643   void * jresult ;
25644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25645   Dali::Vector4 result;
25646
25647   arg1 = (Dali::RenderTask *)jarg1;
25648   {
25649     try {
25650       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25651     } catch (std::out_of_range& e) {
25652       {
25653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25654       };
25655     } catch (std::exception& e) {
25656       {
25657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25658       };
25659     } catch (...) {
25660       {
25661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25662       };
25663     }
25664   }
25665   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25666   return jresult;
25667 }
25668
25669
25670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25672   bool arg2 ;
25673
25674   arg1 = (Dali::RenderTask *)jarg1;
25675   arg2 = jarg2 ? true : false;
25676   {
25677     try {
25678       (arg1)->SetClearEnabled(arg2);
25679     } catch (std::out_of_range& e) {
25680       {
25681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25682       };
25683     } catch (std::exception& e) {
25684       {
25685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25686       };
25687     } catch (...) {
25688       {
25689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25690       };
25691     }
25692   }
25693 }
25694
25695
25696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25697   unsigned int jresult ;
25698   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25699   bool result;
25700
25701   arg1 = (Dali::RenderTask *)jarg1;
25702   {
25703     try {
25704       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25705     } catch (std::out_of_range& e) {
25706       {
25707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25708       };
25709     } catch (std::exception& e) {
25710       {
25711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25712       };
25713     } catch (...) {
25714       {
25715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25716       };
25717     }
25718   }
25719   jresult = result;
25720   return jresult;
25721 }
25722
25723
25724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25725   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25726   bool arg2 ;
25727
25728   arg1 = (Dali::RenderTask *)jarg1;
25729   arg2 = jarg2 ? true : false;
25730   {
25731     try {
25732       (arg1)->SetCullMode(arg2);
25733     } catch (std::out_of_range& e) {
25734       {
25735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25736       };
25737     } catch (std::exception& e) {
25738       {
25739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25740       };
25741     } catch (...) {
25742       {
25743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25744       };
25745     }
25746   }
25747 }
25748
25749
25750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25751   unsigned int jresult ;
25752   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25753   bool result;
25754
25755   arg1 = (Dali::RenderTask *)jarg1;
25756   {
25757     try {
25758       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25759     } catch (std::out_of_range& e) {
25760       {
25761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25762       };
25763     } catch (std::exception& e) {
25764       {
25765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25766       };
25767     } catch (...) {
25768       {
25769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25770       };
25771     }
25772   }
25773   jresult = result;
25774   return jresult;
25775 }
25776
25777
25778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25779   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25780   unsigned int arg2 ;
25781
25782   arg1 = (Dali::RenderTask *)jarg1;
25783   arg2 = (unsigned int)jarg2;
25784   {
25785     try {
25786       (arg1)->SetRefreshRate(arg2);
25787     } catch (std::out_of_range& e) {
25788       {
25789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25790       };
25791     } catch (std::exception& e) {
25792       {
25793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25794       };
25795     } catch (...) {
25796       {
25797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25798       };
25799     }
25800   }
25801 }
25802
25803
25804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25805   unsigned int jresult ;
25806   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25807   unsigned int result;
25808
25809   arg1 = (Dali::RenderTask *)jarg1;
25810   {
25811     try {
25812       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25813     } catch (std::out_of_range& e) {
25814       {
25815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25816       };
25817     } catch (std::exception& e) {
25818       {
25819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (...) {
25822       {
25823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25824       };
25825     }
25826   }
25827   jresult = result;
25828   return jresult;
25829 }
25830
25831
25832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25833   unsigned int jresult ;
25834   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25835   Dali::Vector3 *arg2 = 0 ;
25836   float *arg3 = 0 ;
25837   float *arg4 = 0 ;
25838   bool result;
25839
25840   arg1 = (Dali::RenderTask *)jarg1;
25841   arg2 = (Dali::Vector3 *)jarg2;
25842   if (!arg2) {
25843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25844     return 0;
25845   }
25846   arg3 = (float *)jarg3;
25847   arg4 = (float *)jarg4;
25848   {
25849     try {
25850       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25851     } catch (std::out_of_range& e) {
25852       {
25853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25854       };
25855     } catch (std::exception& e) {
25856       {
25857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25858       };
25859     } catch (...) {
25860       {
25861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25862       };
25863     }
25864   }
25865   jresult = result;
25866   return jresult;
25867 }
25868
25869
25870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25871   unsigned int jresult ;
25872   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25873   Dali::Actor arg2 ;
25874   float arg3 ;
25875   float arg4 ;
25876   float *arg5 = 0 ;
25877   float *arg6 = 0 ;
25878   Dali::Actor *argp2 ;
25879   bool result;
25880
25881   arg1 = (Dali::RenderTask *)jarg1;
25882   argp2 = (Dali::Actor *)jarg2;
25883   if (!argp2) {
25884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25885     return 0;
25886   }
25887   arg2 = *argp2;
25888   arg3 = (float)jarg3;
25889   arg4 = (float)jarg4;
25890   arg5 = (float *)jarg5;
25891   arg6 = (float *)jarg6;
25892   {
25893     try {
25894       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
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 (...) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25906       };
25907     }
25908   }
25909   jresult = result;
25910   return jresult;
25911 }
25912
25913
25914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25915   void * jresult ;
25916   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25917   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25918
25919   arg1 = (Dali::RenderTask *)jarg1;
25920   {
25921     try {
25922       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25923     } catch (std::out_of_range& e) {
25924       {
25925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25926       };
25927     } catch (std::exception& e) {
25928       {
25929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25930       };
25931     } catch (...) {
25932       {
25933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25934       };
25935     }
25936   }
25937   jresult = (void *)result;
25938   return jresult;
25939 }
25940
25941
25942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25943   void * jresult ;
25944   int arg1 ;
25945   Dali::TouchPoint::State arg2 ;
25946   float arg3 ;
25947   float arg4 ;
25948   Dali::TouchPoint *result = 0 ;
25949
25950   arg1 = (int)jarg1;
25951   arg2 = (Dali::TouchPoint::State)jarg2;
25952   arg3 = (float)jarg3;
25953   arg4 = (float)jarg4;
25954   {
25955     try {
25956       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25957     } catch (std::out_of_range& e) {
25958       {
25959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25960       };
25961     } catch (std::exception& e) {
25962       {
25963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25964       };
25965     } catch (...) {
25966       {
25967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25968       };
25969     }
25970   }
25971   jresult = (void *)result;
25972   return jresult;
25973 }
25974
25975
25976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25977   void * jresult ;
25978   int arg1 ;
25979   Dali::TouchPoint::State arg2 ;
25980   float arg3 ;
25981   float arg4 ;
25982   float arg5 ;
25983   float arg6 ;
25984   Dali::TouchPoint *result = 0 ;
25985
25986   arg1 = (int)jarg1;
25987   arg2 = (Dali::TouchPoint::State)jarg2;
25988   arg3 = (float)jarg3;
25989   arg4 = (float)jarg4;
25990   arg5 = (float)jarg5;
25991   arg6 = (float)jarg6;
25992   {
25993     try {
25994       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25995     } catch (std::out_of_range& e) {
25996       {
25997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25998       };
25999     } catch (std::exception& e) {
26000       {
26001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26002       };
26003     } catch (...) {
26004       {
26005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26006       };
26007     }
26008   }
26009   jresult = (void *)result;
26010   return jresult;
26011 }
26012
26013
26014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26015   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26016
26017   arg1 = (Dali::TouchPoint *)jarg1;
26018   {
26019     try {
26020       delete arg1;
26021     } catch (std::out_of_range& e) {
26022       {
26023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26024       };
26025     } catch (std::exception& e) {
26026       {
26027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26028       };
26029     } catch (...) {
26030       {
26031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26032       };
26033     }
26034   }
26035 }
26036
26037
26038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26039   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26040   int arg2 ;
26041
26042   arg1 = (Dali::TouchPoint *)jarg1;
26043   arg2 = (int)jarg2;
26044   if (arg1) (arg1)->deviceId = arg2;
26045 }
26046
26047
26048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26049   int jresult ;
26050   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26051   int result;
26052
26053   arg1 = (Dali::TouchPoint *)jarg1;
26054   result = (int) ((arg1)->deviceId);
26055   jresult = result;
26056   return jresult;
26057 }
26058
26059
26060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26061   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26062   Dali::TouchPoint::State arg2 ;
26063
26064   arg1 = (Dali::TouchPoint *)jarg1;
26065   arg2 = (Dali::TouchPoint::State)jarg2;
26066   if (arg1) (arg1)->state = arg2;
26067 }
26068
26069
26070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26071   int jresult ;
26072   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26073   Dali::TouchPoint::State result;
26074
26075   arg1 = (Dali::TouchPoint *)jarg1;
26076   result = (Dali::TouchPoint::State) ((arg1)->state);
26077   jresult = (int)result;
26078   return jresult;
26079 }
26080
26081
26082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26083   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26084   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26085
26086   arg1 = (Dali::TouchPoint *)jarg1;
26087   arg2 = (Dali::Actor *)jarg2;
26088   if (arg1) (arg1)->hitActor = *arg2;
26089 }
26090
26091
26092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26093   void * jresult ;
26094   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26095   Dali::Actor *result = 0 ;
26096
26097   arg1 = (Dali::TouchPoint *)jarg1;
26098   result = (Dali::Actor *)& ((arg1)->hitActor);
26099   jresult = (void *)result;
26100   return jresult;
26101 }
26102
26103
26104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26105   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26106   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26107
26108   arg1 = (Dali::TouchPoint *)jarg1;
26109   arg2 = (Dali::Vector2 *)jarg2;
26110   if (arg1) (arg1)->local = *arg2;
26111 }
26112
26113
26114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26115   void * jresult ;
26116   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26117   Dali::Vector2 *result = 0 ;
26118
26119   arg1 = (Dali::TouchPoint *)jarg1;
26120   result = (Dali::Vector2 *)& ((arg1)->local);
26121   jresult = (void *)result;
26122   return jresult;
26123 }
26124
26125
26126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26127   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26128   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26129
26130   arg1 = (Dali::TouchPoint *)jarg1;
26131   arg2 = (Dali::Vector2 *)jarg2;
26132   if (arg1) (arg1)->screen = *arg2;
26133 }
26134
26135
26136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26137   void * jresult ;
26138   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26139   Dali::Vector2 *result = 0 ;
26140
26141   arg1 = (Dali::TouchPoint *)jarg1;
26142   result = (Dali::Vector2 *)& ((arg1)->screen);
26143   jresult = (void *)result;
26144   return jresult;
26145 }
26146
26147
26148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26149   void * jresult ;
26150   Dali::TouchData *result = 0 ;
26151
26152   {
26153     try {
26154       result = (Dali::TouchData *)new Dali::TouchData();
26155     } catch (std::out_of_range& e) {
26156       {
26157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26158       };
26159     } catch (std::exception& e) {
26160       {
26161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26162       };
26163     } catch (...) {
26164       {
26165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26166       };
26167     }
26168   }
26169   jresult = (void *)result;
26170   return jresult;
26171 }
26172
26173
26174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26175   void * jresult ;
26176   Dali::TouchData *arg1 = 0 ;
26177   Dali::TouchData *result = 0 ;
26178
26179   arg1 = (Dali::TouchData *)jarg1;
26180   if (!arg1) {
26181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26182     return 0;
26183   }
26184   {
26185     try {
26186       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26187     } catch (std::out_of_range& e) {
26188       {
26189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26190       };
26191     } catch (std::exception& e) {
26192       {
26193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26194       };
26195     } catch (...) {
26196       {
26197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26198       };
26199     }
26200   }
26201   jresult = (void *)result;
26202   return jresult;
26203 }
26204
26205
26206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26207   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26208
26209   arg1 = (Dali::TouchData *)jarg1;
26210   {
26211     try {
26212       delete arg1;
26213     } catch (std::out_of_range& e) {
26214       {
26215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26216       };
26217     } catch (std::exception& e) {
26218       {
26219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26220       };
26221     } catch (...) {
26222       {
26223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26224       };
26225     }
26226   }
26227 }
26228
26229
26230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26231   void * jresult ;
26232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26233   Dali::TouchData *arg2 = 0 ;
26234   Dali::TouchData *result = 0 ;
26235
26236   arg1 = (Dali::TouchData *)jarg1;
26237   arg2 = (Dali::TouchData *)jarg2;
26238   if (!arg2) {
26239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26240     return 0;
26241   }
26242   {
26243     try {
26244       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26245     } catch (std::out_of_range& e) {
26246       {
26247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26248       };
26249     } catch (std::exception& e) {
26250       {
26251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26252       };
26253     } catch (...) {
26254       {
26255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26256       };
26257     }
26258   }
26259   jresult = (void *)result;
26260   return jresult;
26261 }
26262
26263
26264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26265   unsigned long jresult ;
26266   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26267   unsigned long result;
26268
26269   arg1 = (Dali::TouchData *)jarg1;
26270   {
26271     try {
26272       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26273     } catch (std::out_of_range& e) {
26274       {
26275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26276       };
26277     } catch (std::exception& e) {
26278       {
26279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26280       };
26281     } catch (...) {
26282       {
26283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26284       };
26285     }
26286   }
26287   jresult = (unsigned long)result;
26288   return jresult;
26289 }
26290
26291
26292 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26293   unsigned long jresult ;
26294   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26295   std::size_t result;
26296
26297   arg1 = (Dali::TouchData *)jarg1;
26298   {
26299     try {
26300       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26301     } catch (std::out_of_range& e) {
26302       {
26303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26304       };
26305     } catch (std::exception& e) {
26306       {
26307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26308       };
26309     } catch (...) {
26310       {
26311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26312       };
26313     }
26314   }
26315   jresult = (unsigned long)result;
26316   return jresult;
26317 }
26318
26319
26320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26321   int jresult ;
26322   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26323   std::size_t arg2 ;
26324   int32_t result;
26325
26326   arg1 = (Dali::TouchData *)jarg1;
26327   arg2 = (std::size_t)jarg2;
26328   {
26329     try {
26330       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26331     } catch (std::out_of_range& e) {
26332       {
26333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26334       };
26335     } catch (std::exception& e) {
26336       {
26337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26338       };
26339     } catch (...) {
26340       {
26341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26342       };
26343     }
26344   }
26345   jresult = result;
26346   return jresult;
26347 }
26348
26349
26350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26351   int jresult ;
26352   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26353   std::size_t arg2 ;
26354   Dali::PointState::Type result;
26355
26356   arg1 = (Dali::TouchData *)jarg1;
26357   arg2 = (std::size_t)jarg2;
26358   {
26359     try {
26360       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26361     } catch (std::out_of_range& e) {
26362       {
26363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26364       };
26365     } catch (std::exception& e) {
26366       {
26367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26368       };
26369     } catch (...) {
26370       {
26371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26372       };
26373     }
26374   }
26375   jresult = (int)result;
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26381   void * jresult ;
26382   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26383   std::size_t arg2 ;
26384   Dali::Actor result;
26385
26386   arg1 = (Dali::TouchData *)jarg1;
26387   arg2 = (std::size_t)jarg2;
26388   {
26389     try {
26390       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26391     } catch (std::out_of_range& e) {
26392       {
26393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26394       };
26395     } catch (std::exception& e) {
26396       {
26397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26398       };
26399     } catch (...) {
26400       {
26401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26402       };
26403     }
26404   }
26405   jresult = new Dali::Actor((const Dali::Actor &)result);
26406   return jresult;
26407 }
26408
26409
26410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26411   void * jresult ;
26412   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26413   std::size_t arg2 ;
26414   Dali::Vector2 *result = 0 ;
26415
26416   arg1 = (Dali::TouchData *)jarg1;
26417   arg2 = (std::size_t)jarg2;
26418   {
26419     try {
26420       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26421     } catch (std::out_of_range& e) {
26422       {
26423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26424       };
26425     } catch (std::exception& e) {
26426       {
26427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26428       };
26429     } catch (...) {
26430       {
26431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26432       };
26433     }
26434   }
26435   jresult = (void *)result;
26436   return jresult;
26437 }
26438
26439
26440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26441   void * jresult ;
26442   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26443   std::size_t arg2 ;
26444   Dali::Vector2 *result = 0 ;
26445
26446   arg1 = (Dali::TouchData *)jarg1;
26447   arg2 = (std::size_t)jarg2;
26448   {
26449     try {
26450       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26451     } catch (std::out_of_range& e) {
26452       {
26453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26454       };
26455     } catch (std::exception& e) {
26456       {
26457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26458       };
26459     } catch (...) {
26460       {
26461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26462       };
26463     }
26464   }
26465   jresult = (void *)result;
26466   return jresult;
26467 }
26468
26469
26470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26471   float jresult ;
26472   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26473   std::size_t arg2 ;
26474   float result;
26475
26476   arg1 = (Dali::TouchData *)jarg1;
26477   arg2 = (std::size_t)jarg2;
26478   {
26479     try {
26480       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26481     } catch (std::out_of_range& e) {
26482       {
26483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26484       };
26485     } catch (std::exception& e) {
26486       {
26487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26488       };
26489     } catch (...) {
26490       {
26491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26492       };
26493     }
26494   }
26495   jresult = result;
26496   return jresult;
26497 }
26498
26499
26500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26501   void * jresult ;
26502   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26503   std::size_t arg2 ;
26504   Dali::Vector2 *result = 0 ;
26505
26506   arg1 = (Dali::TouchData *)jarg1;
26507   arg2 = (std::size_t)jarg2;
26508   {
26509     try {
26510       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26511     } catch (std::out_of_range& e) {
26512       {
26513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26514       };
26515     } catch (std::exception& e) {
26516       {
26517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26518       };
26519     } catch (...) {
26520       {
26521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26522       };
26523     }
26524   }
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26531   float jresult ;
26532   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26533   std::size_t arg2 ;
26534   float result;
26535
26536   arg1 = (Dali::TouchData *)jarg1;
26537   arg2 = (std::size_t)jarg2;
26538   {
26539     try {
26540       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26541     } catch (std::out_of_range& e) {
26542       {
26543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26544       };
26545     } catch (std::exception& e) {
26546       {
26547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26548       };
26549     } catch (...) {
26550       {
26551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26552       };
26553     }
26554   }
26555   jresult = result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26561   void * jresult ;
26562   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26563   std::size_t arg2 ;
26564   Dali::Degree result;
26565
26566   arg1 = (Dali::TouchData *)jarg1;
26567   arg2 = (std::size_t)jarg2;
26568   {
26569     try {
26570       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26571     } catch (std::out_of_range& e) {
26572       {
26573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26574       };
26575     } catch (std::exception& e) {
26576       {
26577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26578       };
26579     } catch (...) {
26580       {
26581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26582       };
26583     }
26584   }
26585   jresult = new Dali::Degree((const Dali::Degree &)result);
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26591   void * jresult ;
26592   Dali::GestureDetector *result = 0 ;
26593
26594   {
26595     try {
26596       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26597     } catch (std::out_of_range& e) {
26598       {
26599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26600       };
26601     } catch (std::exception& e) {
26602       {
26603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26604       };
26605     } catch (...) {
26606       {
26607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26608       };
26609     }
26610   }
26611   jresult = (void *)result;
26612   return jresult;
26613 }
26614
26615
26616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26617   void * jresult ;
26618   Dali::BaseHandle arg1 ;
26619   Dali::BaseHandle *argp1 ;
26620   Dali::GestureDetector result;
26621
26622   argp1 = (Dali::BaseHandle *)jarg1;
26623   if (!argp1) {
26624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26625     return 0;
26626   }
26627   arg1 = *argp1;
26628   {
26629     try {
26630       result = Dali::GestureDetector::DownCast(arg1);
26631     } catch (std::out_of_range& e) {
26632       {
26633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26634       };
26635     } catch (std::exception& e) {
26636       {
26637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26638       };
26639     } catch (...) {
26640       {
26641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26642       };
26643     }
26644   }
26645   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26651   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26652
26653   arg1 = (Dali::GestureDetector *)jarg1;
26654   {
26655     try {
26656       delete arg1;
26657     } catch (std::out_of_range& e) {
26658       {
26659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26660       };
26661     } catch (std::exception& e) {
26662       {
26663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26664       };
26665     } catch (...) {
26666       {
26667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26668       };
26669     }
26670   }
26671 }
26672
26673
26674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26675   void * jresult ;
26676   Dali::GestureDetector *arg1 = 0 ;
26677   Dali::GestureDetector *result = 0 ;
26678
26679   arg1 = (Dali::GestureDetector *)jarg1;
26680   if (!arg1) {
26681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26682     return 0;
26683   }
26684   {
26685     try {
26686       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26687     } catch (std::out_of_range& e) {
26688       {
26689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26690       };
26691     } catch (std::exception& e) {
26692       {
26693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26694       };
26695     } catch (...) {
26696       {
26697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26698       };
26699     }
26700   }
26701   jresult = (void *)result;
26702   return jresult;
26703 }
26704
26705
26706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26707   void * jresult ;
26708   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26709   Dali::GestureDetector *arg2 = 0 ;
26710   Dali::GestureDetector *result = 0 ;
26711
26712   arg1 = (Dali::GestureDetector *)jarg1;
26713   arg2 = (Dali::GestureDetector *)jarg2;
26714   if (!arg2) {
26715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26716     return 0;
26717   }
26718   {
26719     try {
26720       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26721     } catch (std::out_of_range& e) {
26722       {
26723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26724       };
26725     } catch (std::exception& e) {
26726       {
26727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26728       };
26729     } catch (...) {
26730       {
26731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26732       };
26733     }
26734   }
26735   jresult = (void *)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26741   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26742   Dali::Actor arg2 ;
26743   Dali::Actor *argp2 ;
26744
26745   arg1 = (Dali::GestureDetector *)jarg1;
26746   argp2 = (Dali::Actor *)jarg2;
26747   if (!argp2) {
26748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26749     return ;
26750   }
26751   arg2 = *argp2;
26752   {
26753     try {
26754       (arg1)->Attach(arg2);
26755     } catch (std::out_of_range& e) {
26756       {
26757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26758       };
26759     } catch (std::exception& e) {
26760       {
26761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26762       };
26763     } catch (...) {
26764       {
26765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26766       };
26767     }
26768   }
26769 }
26770
26771
26772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26773   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26774   Dali::Actor arg2 ;
26775   Dali::Actor *argp2 ;
26776
26777   arg1 = (Dali::GestureDetector *)jarg1;
26778   argp2 = (Dali::Actor *)jarg2;
26779   if (!argp2) {
26780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26781     return ;
26782   }
26783   arg2 = *argp2;
26784   {
26785     try {
26786       (arg1)->Detach(arg2);
26787     } catch (std::out_of_range& e) {
26788       {
26789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26790       };
26791     } catch (std::exception& e) {
26792       {
26793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26794       };
26795     } catch (...) {
26796       {
26797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26798       };
26799     }
26800   }
26801 }
26802
26803
26804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26805   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26806
26807   arg1 = (Dali::GestureDetector *)jarg1;
26808   {
26809     try {
26810       (arg1)->DetachAll();
26811     } catch (std::out_of_range& e) {
26812       {
26813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26814       };
26815     } catch (std::exception& e) {
26816       {
26817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26818       };
26819     } catch (...) {
26820       {
26821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26822       };
26823     }
26824   }
26825 }
26826
26827
26828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26829   unsigned long jresult ;
26830   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26831   size_t result;
26832
26833   arg1 = (Dali::GestureDetector *)jarg1;
26834   {
26835     try {
26836       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26837     } catch (std::out_of_range& e) {
26838       {
26839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26840       };
26841     } catch (std::exception& e) {
26842       {
26843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26844       };
26845     } catch (...) {
26846       {
26847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26848       };
26849     }
26850   }
26851   jresult = (unsigned long)result;
26852   return jresult;
26853 }
26854
26855
26856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26857   void * jresult ;
26858   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26859   size_t arg2 ;
26860   Dali::Actor result;
26861
26862   arg1 = (Dali::GestureDetector *)jarg1;
26863   arg2 = (size_t)jarg2;
26864   {
26865     try {
26866       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26867     } catch (std::out_of_range& e) {
26868       {
26869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26870       };
26871     } catch (std::exception& e) {
26872       {
26873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26874       };
26875     } catch (...) {
26876       {
26877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26878       };
26879     }
26880   }
26881   jresult = new Dali::Actor((const Dali::Actor &)result);
26882   return jresult;
26883 }
26884
26885
26886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26887   void * jresult ;
26888   Dali::Gesture *arg1 = 0 ;
26889   Dali::Gesture *result = 0 ;
26890
26891   arg1 = (Dali::Gesture *)jarg1;
26892   if (!arg1) {
26893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26894     return 0;
26895   }
26896   {
26897     try {
26898       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26899     } catch (std::out_of_range& e) {
26900       {
26901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26902       };
26903     } catch (std::exception& e) {
26904       {
26905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (...) {
26908       {
26909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26910       };
26911     }
26912   }
26913   jresult = (void *)result;
26914   return jresult;
26915 }
26916
26917
26918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26919   void * jresult ;
26920   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26921   Dali::Gesture *arg2 = 0 ;
26922   Dali::Gesture *result = 0 ;
26923
26924   arg1 = (Dali::Gesture *)jarg1;
26925   arg2 = (Dali::Gesture *)jarg2;
26926   if (!arg2) {
26927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26928     return 0;
26929   }
26930   {
26931     try {
26932       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26933     } catch (std::out_of_range& e) {
26934       {
26935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26936       };
26937     } catch (std::exception& e) {
26938       {
26939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26940       };
26941     } catch (...) {
26942       {
26943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26944       };
26945     }
26946   }
26947   jresult = (void *)result;
26948   return jresult;
26949 }
26950
26951
26952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26953   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26954
26955   arg1 = (Dali::Gesture *)jarg1;
26956   {
26957     try {
26958       delete arg1;
26959     } catch (std::out_of_range& e) {
26960       {
26961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26962       };
26963     } catch (std::exception& e) {
26964       {
26965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26966       };
26967     } catch (...) {
26968       {
26969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26970       };
26971     }
26972   }
26973 }
26974
26975
26976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26977   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26978   Dali::Gesture::Type arg2 ;
26979
26980   arg1 = (Dali::Gesture *)jarg1;
26981   arg2 = (Dali::Gesture::Type)jarg2;
26982   if (arg1) (arg1)->type = arg2;
26983 }
26984
26985
26986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26987   int jresult ;
26988   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26989   Dali::Gesture::Type result;
26990
26991   arg1 = (Dali::Gesture *)jarg1;
26992   result = (Dali::Gesture::Type) ((arg1)->type);
26993   jresult = (int)result;
26994   return jresult;
26995 }
26996
26997
26998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26999   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27000   Dali::Gesture::State arg2 ;
27001
27002   arg1 = (Dali::Gesture *)jarg1;
27003   arg2 = (Dali::Gesture::State)jarg2;
27004   if (arg1) (arg1)->state = arg2;
27005 }
27006
27007
27008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27009   int jresult ;
27010   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27011   Dali::Gesture::State result;
27012
27013   arg1 = (Dali::Gesture *)jarg1;
27014   result = (Dali::Gesture::State) ((arg1)->state);
27015   jresult = (int)result;
27016   return jresult;
27017 }
27018
27019
27020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27021   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27022   unsigned int arg2 ;
27023
27024   arg1 = (Dali::Gesture *)jarg1;
27025   arg2 = (unsigned int)jarg2;
27026   if (arg1) (arg1)->time = arg2;
27027 }
27028
27029
27030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27031   unsigned int jresult ;
27032   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27033   unsigned int result;
27034
27035   arg1 = (Dali::Gesture *)jarg1;
27036   result = (unsigned int) ((arg1)->time);
27037   jresult = result;
27038   return jresult;
27039 }
27040
27041
27042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27043   void * jresult ;
27044   Dali::HoverEvent *result = 0 ;
27045
27046   {
27047     try {
27048       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27049     } catch (std::out_of_range& e) {
27050       {
27051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27052       };
27053     } catch (std::exception& e) {
27054       {
27055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27056       };
27057     } catch (...) {
27058       {
27059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27060       };
27061     }
27062   }
27063   jresult = (void *)result;
27064   return jresult;
27065 }
27066
27067
27068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27069   void * jresult ;
27070   unsigned long arg1 ;
27071   Dali::HoverEvent *result = 0 ;
27072
27073   arg1 = (unsigned long)jarg1;
27074   {
27075     try {
27076       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27077     } catch (std::out_of_range& e) {
27078       {
27079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27080       };
27081     } catch (std::exception& e) {
27082       {
27083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27084       };
27085     } catch (...) {
27086       {
27087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27088       };
27089     }
27090   }
27091   jresult = (void *)result;
27092   return jresult;
27093 }
27094
27095
27096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27097   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27098
27099   arg1 = (Dali::HoverEvent *)jarg1;
27100   {
27101     try {
27102       delete arg1;
27103     } catch (std::out_of_range& e) {
27104       {
27105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27106       };
27107     } catch (std::exception& e) {
27108       {
27109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27110       };
27111     } catch (...) {
27112       {
27113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27114       };
27115     }
27116   }
27117 }
27118
27119
27120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27121   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27122   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27123
27124   arg1 = (Dali::HoverEvent *)jarg1;
27125   arg2 = (Dali::TouchPointContainer *)jarg2;
27126   if (arg1) (arg1)->points = *arg2;
27127 }
27128
27129
27130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27131   void * jresult ;
27132   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27133   Dali::TouchPointContainer *result = 0 ;
27134
27135   arg1 = (Dali::HoverEvent *)jarg1;
27136   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27137   jresult = (void *)result;
27138   return jresult;
27139 }
27140
27141
27142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27143   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27144   unsigned long arg2 ;
27145
27146   arg1 = (Dali::HoverEvent *)jarg1;
27147   arg2 = (unsigned long)jarg2;
27148   if (arg1) (arg1)->time = arg2;
27149 }
27150
27151
27152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27153   unsigned long jresult ;
27154   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27155   unsigned long result;
27156
27157   arg1 = (Dali::HoverEvent *)jarg1;
27158   result = (unsigned long) ((arg1)->time);
27159   jresult = (unsigned long)result;
27160   return jresult;
27161 }
27162
27163
27164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27165   unsigned int jresult ;
27166   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27167   unsigned int result;
27168
27169   arg1 = (Dali::HoverEvent *)jarg1;
27170   {
27171     try {
27172       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27173     } catch (std::out_of_range& e) {
27174       {
27175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27176       };
27177     } catch (std::exception& e) {
27178       {
27179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27180       };
27181     } catch (...) {
27182       {
27183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27184       };
27185     }
27186   }
27187   jresult = result;
27188   return jresult;
27189 }
27190
27191
27192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27193   void * jresult ;
27194   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27195   unsigned int arg2 ;
27196   Dali::TouchPoint *result = 0 ;
27197
27198   arg1 = (Dali::HoverEvent *)jarg1;
27199   arg2 = (unsigned int)jarg2;
27200   {
27201     try {
27202       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27203     } catch (std::out_of_range& e) {
27204       {
27205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27206       };
27207     } catch (std::exception& e) {
27208       {
27209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27210       };
27211     } catch (...) {
27212       {
27213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27214       };
27215     }
27216   }
27217   jresult = (void *)result;
27218   return jresult;
27219 }
27220
27221
27222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27223   void * jresult ;
27224   Dali::KeyEvent *result = 0 ;
27225
27226   {
27227     try {
27228       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27229     } catch (std::out_of_range& e) {
27230       {
27231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27232       };
27233     } catch (std::exception& e) {
27234       {
27235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27236       };
27237     } catch (...) {
27238       {
27239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27240       };
27241     }
27242   }
27243   jresult = (void *)result;
27244   return jresult;
27245 }
27246
27247
27248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27249   void * jresult ;
27250   std::string *arg1 = 0 ;
27251   std::string *arg2 = 0 ;
27252   int arg3 ;
27253   int arg4 ;
27254   unsigned long arg5 ;
27255   Dali::KeyEvent::State *arg6 = 0 ;
27256   Dali::KeyEvent::State temp6 ;
27257   Dali::KeyEvent *result = 0 ;
27258
27259   if (!jarg1) {
27260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27261     return 0;
27262   }
27263   std::string arg1_str(jarg1);
27264   arg1 = &arg1_str;
27265   if (!jarg2) {
27266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27267     return 0;
27268   }
27269   std::string arg2_str(jarg2);
27270   arg2 = &arg2_str;
27271   arg3 = (int)jarg3;
27272   arg4 = (int)jarg4;
27273   arg5 = (unsigned long)jarg5;
27274   temp6 = (Dali::KeyEvent::State)jarg6;
27275   arg6 = &temp6;
27276   {
27277     try {
27278       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27279     } catch (std::out_of_range& e) {
27280       {
27281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27282       };
27283     } catch (std::exception& e) {
27284       {
27285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27286       };
27287     } catch (...) {
27288       {
27289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27290       };
27291     }
27292   }
27293   jresult = (void *)result;
27294
27295   //argout typemap for const std::string&
27296
27297
27298   //argout typemap for const std::string&
27299
27300   return jresult;
27301 }
27302
27303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27304   void * jresult ;
27305   Dali::KeyEvent *arg1 = 0 ;
27306   Dali::KeyEvent *result = 0 ;
27307
27308   arg1 = (Dali::KeyEvent *)jarg1;
27309   if (!arg1) {
27310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27311     return 0;
27312   }
27313   {
27314     try {
27315       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27316     } catch (std::out_of_range& e) {
27317       {
27318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27319       };
27320     } catch (std::exception& e) {
27321       {
27322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27323       };
27324     } catch (...) {
27325       {
27326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27327       };
27328     }
27329   }
27330   jresult = (void *)result;
27331   return jresult;
27332 }
27333
27334
27335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27336   void * jresult ;
27337   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27338   Dali::KeyEvent *arg2 = 0 ;
27339   Dali::KeyEvent *result = 0 ;
27340
27341   arg1 = (Dali::KeyEvent *)jarg1;
27342   arg2 = (Dali::KeyEvent *)jarg2;
27343   if (!arg2) {
27344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27345     return 0;
27346   }
27347   {
27348     try {
27349       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27350     } catch (std::out_of_range& e) {
27351       {
27352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (std::exception& e) {
27355       {
27356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27361       };
27362     }
27363   }
27364   jresult = (void *)result;
27365   return jresult;
27366 }
27367
27368
27369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27371
27372   arg1 = (Dali::KeyEvent *)jarg1;
27373   {
27374     try {
27375       delete arg1;
27376     } catch (std::out_of_range& e) {
27377       {
27378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27379       };
27380     } catch (std::exception& e) {
27381       {
27382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27383       };
27384     } catch (...) {
27385       {
27386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27387       };
27388     }
27389   }
27390 }
27391
27392
27393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27394   unsigned int jresult ;
27395   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27396   bool result;
27397
27398   arg1 = (Dali::KeyEvent *)jarg1;
27399   {
27400     try {
27401       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27402     } catch (std::out_of_range& e) {
27403       {
27404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27405       };
27406     } catch (std::exception& e) {
27407       {
27408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27409       };
27410     } catch (...) {
27411       {
27412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27413       };
27414     }
27415   }
27416   jresult = result;
27417   return jresult;
27418 }
27419
27420
27421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27422   unsigned int jresult ;
27423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27424   bool result;
27425
27426   arg1 = (Dali::KeyEvent *)jarg1;
27427   {
27428     try {
27429       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27430     } catch (std::out_of_range& e) {
27431       {
27432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27433       };
27434     } catch (std::exception& e) {
27435       {
27436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27437       };
27438     } catch (...) {
27439       {
27440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27441       };
27442     }
27443   }
27444   jresult = result;
27445   return jresult;
27446 }
27447
27448
27449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27450   unsigned int jresult ;
27451   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27452   bool result;
27453
27454   arg1 = (Dali::KeyEvent *)jarg1;
27455   {
27456     try {
27457       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27458     } catch (std::out_of_range& e) {
27459       {
27460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27461       };
27462     } catch (std::exception& e) {
27463       {
27464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27465       };
27466     } catch (...) {
27467       {
27468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27469       };
27470     }
27471   }
27472   jresult = result;
27473   return jresult;
27474 }
27475
27476
27477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27478   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27479   std::string *arg2 = 0 ;
27480
27481   arg1 = (Dali::KeyEvent *)jarg1;
27482   if (!jarg2) {
27483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27484     return ;
27485   }
27486   std::string arg2_str(jarg2);
27487   arg2 = &arg2_str;
27488   if (arg1) (arg1)->keyPressedName = *arg2;
27489
27490   //argout typemap for const std::string&
27491
27492 }
27493
27494
27495 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27496   char * jresult ;
27497   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27498   std::string *result = 0 ;
27499
27500   arg1 = (Dali::KeyEvent *)jarg1;
27501   result = (std::string *) & ((arg1)->keyPressedName);
27502   jresult = SWIG_csharp_string_callback(result->c_str());
27503   return jresult;
27504 }
27505
27506
27507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27508   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27509   std::string *arg2 = 0 ;
27510
27511   arg1 = (Dali::KeyEvent *)jarg1;
27512   if (!jarg2) {
27513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27514     return ;
27515   }
27516   std::string arg2_str(jarg2);
27517   arg2 = &arg2_str;
27518   if (arg1) (arg1)->keyPressed = *arg2;
27519
27520   //argout typemap for const std::string&
27521
27522 }
27523
27524
27525 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27526   char * jresult ;
27527   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27528   std::string *result = 0 ;
27529
27530   arg1 = (Dali::KeyEvent *)jarg1;
27531   result = (std::string *) & ((arg1)->keyPressed);
27532   jresult = SWIG_csharp_string_callback(result->c_str());
27533   return jresult;
27534 }
27535
27536
27537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27538   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27539   int arg2 ;
27540
27541   arg1 = (Dali::KeyEvent *)jarg1;
27542   arg2 = (int)jarg2;
27543   if (arg1) (arg1)->keyCode = arg2;
27544 }
27545
27546
27547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27548   int jresult ;
27549   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27550   int result;
27551
27552   arg1 = (Dali::KeyEvent *)jarg1;
27553   result = (int) ((arg1)->keyCode);
27554   jresult = result;
27555   return jresult;
27556 }
27557
27558
27559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27560   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27561   int arg2 ;
27562
27563   arg1 = (Dali::KeyEvent *)jarg1;
27564   arg2 = (int)jarg2;
27565   if (arg1) (arg1)->keyModifier = arg2;
27566 }
27567
27568
27569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27570   int jresult ;
27571   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27572   int result;
27573
27574   arg1 = (Dali::KeyEvent *)jarg1;
27575   result = (int) ((arg1)->keyModifier);
27576   jresult = result;
27577   return jresult;
27578 }
27579
27580
27581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27582   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27583   unsigned long arg2 ;
27584
27585   arg1 = (Dali::KeyEvent *)jarg1;
27586   arg2 = (unsigned long)jarg2;
27587   if (arg1) (arg1)->time = arg2;
27588 }
27589
27590
27591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27592   unsigned long jresult ;
27593   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27594   unsigned long result;
27595
27596   arg1 = (Dali::KeyEvent *)jarg1;
27597   result = (unsigned long) ((arg1)->time);
27598   jresult = (unsigned long)result;
27599   return jresult;
27600 }
27601
27602
27603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27604   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27605   Dali::KeyEvent::State arg2 ;
27606
27607   arg1 = (Dali::KeyEvent *)jarg1;
27608   arg2 = (Dali::KeyEvent::State)jarg2;
27609   if (arg1) (arg1)->state = arg2;
27610 }
27611
27612
27613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27614   int jresult ;
27615   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27616   Dali::KeyEvent::State result;
27617
27618   arg1 = (Dali::KeyEvent *)jarg1;
27619   result = (Dali::KeyEvent::State) ((arg1)->state);
27620   jresult = (int)result;
27621   return jresult;
27622 }
27623
27624
27625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27626   void * jresult ;
27627   Dali::LongPressGestureDetector *result = 0 ;
27628
27629   {
27630     try {
27631       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27632     } catch (std::out_of_range& e) {
27633       {
27634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27635       };
27636     } catch (std::exception& e) {
27637       {
27638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27639       };
27640     } catch (...) {
27641       {
27642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27643       };
27644     }
27645   }
27646   jresult = (void *)result;
27647   return jresult;
27648 }
27649
27650
27651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27652   void * jresult ;
27653   Dali::LongPressGestureDetector result;
27654
27655   {
27656     try {
27657       result = Dali::LongPressGestureDetector::New();
27658     } catch (std::out_of_range& e) {
27659       {
27660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27661       };
27662     } catch (std::exception& e) {
27663       {
27664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27665       };
27666     } catch (...) {
27667       {
27668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27669       };
27670     }
27671   }
27672   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27673   return jresult;
27674 }
27675
27676
27677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27678   void * jresult ;
27679   unsigned int arg1 ;
27680   Dali::LongPressGestureDetector result;
27681
27682   arg1 = (unsigned int)jarg1;
27683   {
27684     try {
27685       result = Dali::LongPressGestureDetector::New(arg1);
27686     } catch (std::out_of_range& e) {
27687       {
27688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27689       };
27690     } catch (std::exception& e) {
27691       {
27692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27693       };
27694     } catch (...) {
27695       {
27696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27697       };
27698     }
27699   }
27700   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27701   return jresult;
27702 }
27703
27704
27705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27706   void * jresult ;
27707   unsigned int arg1 ;
27708   unsigned int arg2 ;
27709   Dali::LongPressGestureDetector result;
27710
27711   arg1 = (unsigned int)jarg1;
27712   arg2 = (unsigned int)jarg2;
27713   {
27714     try {
27715       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27716     } catch (std::out_of_range& e) {
27717       {
27718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27719       };
27720     } catch (std::exception& e) {
27721       {
27722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27723       };
27724     } catch (...) {
27725       {
27726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27727       };
27728     }
27729   }
27730   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27736   void * jresult ;
27737   Dali::BaseHandle arg1 ;
27738   Dali::BaseHandle *argp1 ;
27739   Dali::LongPressGestureDetector result;
27740
27741   argp1 = (Dali::BaseHandle *)jarg1;
27742   if (!argp1) {
27743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27744     return 0;
27745   }
27746   arg1 = *argp1;
27747   {
27748     try {
27749       result = Dali::LongPressGestureDetector::DownCast(arg1);
27750     } catch (std::out_of_range& e) {
27751       {
27752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27753       };
27754     } catch (std::exception& e) {
27755       {
27756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27757       };
27758     } catch (...) {
27759       {
27760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27761       };
27762     }
27763   }
27764   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27765   return jresult;
27766 }
27767
27768
27769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27770   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27771
27772   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27773   {
27774     try {
27775       delete arg1;
27776     } catch (std::out_of_range& e) {
27777       {
27778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27779       };
27780     } catch (std::exception& e) {
27781       {
27782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27783       };
27784     } catch (...) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27787       };
27788     }
27789   }
27790 }
27791
27792
27793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27794   void * jresult ;
27795   Dali::LongPressGestureDetector *arg1 = 0 ;
27796   Dali::LongPressGestureDetector *result = 0 ;
27797
27798   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27799   if (!arg1) {
27800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27801     return 0;
27802   }
27803   {
27804     try {
27805       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27806     } catch (std::out_of_range& e) {
27807       {
27808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27809       };
27810     } catch (std::exception& e) {
27811       {
27812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27813       };
27814     } catch (...) {
27815       {
27816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27817       };
27818     }
27819   }
27820   jresult = (void *)result;
27821   return jresult;
27822 }
27823
27824
27825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27826   void * jresult ;
27827   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27828   Dali::LongPressGestureDetector *arg2 = 0 ;
27829   Dali::LongPressGestureDetector *result = 0 ;
27830
27831   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27832   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27833   if (!arg2) {
27834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27835     return 0;
27836   }
27837   {
27838     try {
27839       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27840     } catch (std::out_of_range& e) {
27841       {
27842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (std::exception& e) {
27845       {
27846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854   jresult = (void *)result;
27855   return jresult;
27856 }
27857
27858
27859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27860   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27861   unsigned int arg2 ;
27862
27863   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27864   arg2 = (unsigned int)jarg2;
27865   {
27866     try {
27867       (arg1)->SetTouchesRequired(arg2);
27868     } catch (std::out_of_range& e) {
27869       {
27870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27871       };
27872     } catch (std::exception& e) {
27873       {
27874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27875       };
27876     } catch (...) {
27877       {
27878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27879       };
27880     }
27881   }
27882 }
27883
27884
27885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27887   unsigned int arg2 ;
27888   unsigned int arg3 ;
27889
27890   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27891   arg2 = (unsigned int)jarg2;
27892   arg3 = (unsigned int)jarg3;
27893   {
27894     try {
27895       (arg1)->SetTouchesRequired(arg2,arg3);
27896     } catch (std::out_of_range& e) {
27897       {
27898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27899       };
27900     } catch (std::exception& e) {
27901       {
27902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27903       };
27904     } catch (...) {
27905       {
27906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27907       };
27908     }
27909   }
27910 }
27911
27912
27913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27914   unsigned int jresult ;
27915   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27916   unsigned int result;
27917
27918   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27919   {
27920     try {
27921       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27922     } catch (std::out_of_range& e) {
27923       {
27924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27925       };
27926     } catch (std::exception& e) {
27927       {
27928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27929       };
27930     } catch (...) {
27931       {
27932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27933       };
27934     }
27935   }
27936   jresult = result;
27937   return jresult;
27938 }
27939
27940
27941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27942   unsigned int jresult ;
27943   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27944   unsigned int result;
27945
27946   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27947   {
27948     try {
27949       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27950     } catch (std::out_of_range& e) {
27951       {
27952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27953       };
27954     } catch (std::exception& e) {
27955       {
27956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27957       };
27958     } catch (...) {
27959       {
27960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27961       };
27962     }
27963   }
27964   jresult = result;
27965   return jresult;
27966 }
27967
27968
27969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27970   void * jresult ;
27971   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27972   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27973
27974   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27975   {
27976     try {
27977       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27978     } catch (std::out_of_range& e) {
27979       {
27980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (std::exception& e) {
27983       {
27984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (...) {
27987       {
27988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27989       };
27990     }
27991   }
27992   jresult = (void *)result;
27993   return jresult;
27994 }
27995
27996
27997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27998   void * jresult ;
27999   Dali::Gesture::State arg1 ;
28000   Dali::LongPressGesture *result = 0 ;
28001
28002   arg1 = (Dali::Gesture::State)jarg1;
28003   {
28004     try {
28005       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28006     } catch (std::out_of_range& e) {
28007       {
28008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28009       };
28010     } catch (std::exception& e) {
28011       {
28012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28013       };
28014     } catch (...) {
28015       {
28016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28017       };
28018     }
28019   }
28020   jresult = (void *)result;
28021   return jresult;
28022 }
28023
28024
28025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28026   void * jresult ;
28027   Dali::LongPressGesture *arg1 = 0 ;
28028   Dali::LongPressGesture *result = 0 ;
28029
28030   arg1 = (Dali::LongPressGesture *)jarg1;
28031   if (!arg1) {
28032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28033     return 0;
28034   }
28035   {
28036     try {
28037       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28038     } catch (std::out_of_range& e) {
28039       {
28040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28041       };
28042     } catch (std::exception& e) {
28043       {
28044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28045       };
28046     } catch (...) {
28047       {
28048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28049       };
28050     }
28051   }
28052   jresult = (void *)result;
28053   return jresult;
28054 }
28055
28056
28057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28058   void * jresult ;
28059   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28060   Dali::LongPressGesture *arg2 = 0 ;
28061   Dali::LongPressGesture *result = 0 ;
28062
28063   arg1 = (Dali::LongPressGesture *)jarg1;
28064   arg2 = (Dali::LongPressGesture *)jarg2;
28065   if (!arg2) {
28066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28067     return 0;
28068   }
28069   {
28070     try {
28071       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28072     } catch (std::out_of_range& e) {
28073       {
28074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28075       };
28076     } catch (std::exception& e) {
28077       {
28078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28079       };
28080     } catch (...) {
28081       {
28082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28083       };
28084     }
28085   }
28086   jresult = (void *)result;
28087   return jresult;
28088 }
28089
28090
28091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28092   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28093
28094   arg1 = (Dali::LongPressGesture *)jarg1;
28095   {
28096     try {
28097       delete arg1;
28098     } catch (std::out_of_range& e) {
28099       {
28100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28101       };
28102     } catch (std::exception& e) {
28103       {
28104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28105       };
28106     } catch (...) {
28107       {
28108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28109       };
28110     }
28111   }
28112 }
28113
28114
28115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28116   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28117   unsigned int arg2 ;
28118
28119   arg1 = (Dali::LongPressGesture *)jarg1;
28120   arg2 = (unsigned int)jarg2;
28121   if (arg1) (arg1)->numberOfTouches = arg2;
28122 }
28123
28124
28125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28126   unsigned int jresult ;
28127   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28128   unsigned int result;
28129
28130   arg1 = (Dali::LongPressGesture *)jarg1;
28131   result = (unsigned int) ((arg1)->numberOfTouches);
28132   jresult = result;
28133   return jresult;
28134 }
28135
28136
28137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28138   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28139   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28140
28141   arg1 = (Dali::LongPressGesture *)jarg1;
28142   arg2 = (Dali::Vector2 *)jarg2;
28143   if (arg1) (arg1)->screenPoint = *arg2;
28144 }
28145
28146
28147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28148   void * jresult ;
28149   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28150   Dali::Vector2 *result = 0 ;
28151
28152   arg1 = (Dali::LongPressGesture *)jarg1;
28153   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28154   jresult = (void *)result;
28155   return jresult;
28156 }
28157
28158
28159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28160   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28161   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28162
28163   arg1 = (Dali::LongPressGesture *)jarg1;
28164   arg2 = (Dali::Vector2 *)jarg2;
28165   if (arg1) (arg1)->localPoint = *arg2;
28166 }
28167
28168
28169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28170   void * jresult ;
28171   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28172   Dali::Vector2 *result = 0 ;
28173
28174   arg1 = (Dali::LongPressGesture *)jarg1;
28175   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28176   jresult = (void *)result;
28177   return jresult;
28178 }
28179
28180
28181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28182   void * jresult ;
28183   Dali::WheelEvent *result = 0 ;
28184
28185   {
28186     try {
28187       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28188     } catch (std::out_of_range& e) {
28189       {
28190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28191       };
28192     } catch (std::exception& e) {
28193       {
28194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28195       };
28196     } catch (...) {
28197       {
28198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28199       };
28200     }
28201   }
28202   jresult = (void *)result;
28203   return jresult;
28204 }
28205
28206
28207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28208   void * jresult ;
28209   Dali::WheelEvent::Type arg1 ;
28210   int arg2 ;
28211   unsigned int arg3 ;
28212   Dali::Vector2 arg4 ;
28213   int arg5 ;
28214   unsigned int arg6 ;
28215   Dali::Vector2 *argp4 ;
28216   Dali::WheelEvent *result = 0 ;
28217
28218   arg1 = (Dali::WheelEvent::Type)jarg1;
28219   arg2 = (int)jarg2;
28220   arg3 = (unsigned int)jarg3;
28221   argp4 = (Dali::Vector2 *)jarg4;
28222   if (!argp4) {
28223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28224     return 0;
28225   }
28226   arg4 = *argp4;
28227   arg5 = (int)jarg5;
28228   arg6 = (unsigned int)jarg6;
28229   {
28230     try {
28231       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28232     } catch (std::out_of_range& e) {
28233       {
28234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28235       };
28236     } catch (std::exception& e) {
28237       {
28238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28239       };
28240     } catch (...) {
28241       {
28242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28243       };
28244     }
28245   }
28246   jresult = (void *)result;
28247   return jresult;
28248 }
28249
28250
28251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28252   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28253
28254   arg1 = (Dali::WheelEvent *)jarg1;
28255   {
28256     try {
28257       delete arg1;
28258     } catch (std::out_of_range& e) {
28259       {
28260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28261       };
28262     } catch (std::exception& e) {
28263       {
28264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28265       };
28266     } catch (...) {
28267       {
28268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28269       };
28270     }
28271   }
28272 }
28273
28274
28275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28276   unsigned int jresult ;
28277   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28278   bool result;
28279
28280   arg1 = (Dali::WheelEvent *)jarg1;
28281   {
28282     try {
28283       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28284     } catch (std::out_of_range& e) {
28285       {
28286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28287       };
28288     } catch (std::exception& e) {
28289       {
28290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28291       };
28292     } catch (...) {
28293       {
28294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28295       };
28296     }
28297   }
28298   jresult = result;
28299   return jresult;
28300 }
28301
28302
28303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28304   unsigned int jresult ;
28305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28306   bool result;
28307
28308   arg1 = (Dali::WheelEvent *)jarg1;
28309   {
28310     try {
28311       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28312     } catch (std::out_of_range& e) {
28313       {
28314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (std::exception& e) {
28317       {
28318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28319       };
28320     } catch (...) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28323       };
28324     }
28325   }
28326   jresult = result;
28327   return jresult;
28328 }
28329
28330
28331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28332   unsigned int jresult ;
28333   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28334   bool result;
28335
28336   arg1 = (Dali::WheelEvent *)jarg1;
28337   {
28338     try {
28339       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28340     } catch (std::out_of_range& e) {
28341       {
28342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28343       };
28344     } catch (std::exception& e) {
28345       {
28346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28347       };
28348     } catch (...) {
28349       {
28350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28351       };
28352     }
28353   }
28354   jresult = result;
28355   return jresult;
28356 }
28357
28358
28359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28361   Dali::WheelEvent::Type arg2 ;
28362
28363   arg1 = (Dali::WheelEvent *)jarg1;
28364   arg2 = (Dali::WheelEvent::Type)jarg2;
28365   if (arg1) (arg1)->type = arg2;
28366 }
28367
28368
28369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28370   int jresult ;
28371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28372   Dali::WheelEvent::Type result;
28373
28374   arg1 = (Dali::WheelEvent *)jarg1;
28375   result = (Dali::WheelEvent::Type) ((arg1)->type);
28376   jresult = (int)result;
28377   return jresult;
28378 }
28379
28380
28381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28383   int arg2 ;
28384
28385   arg1 = (Dali::WheelEvent *)jarg1;
28386   arg2 = (int)jarg2;
28387   if (arg1) (arg1)->direction = arg2;
28388 }
28389
28390
28391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28392   int jresult ;
28393   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28394   int result;
28395
28396   arg1 = (Dali::WheelEvent *)jarg1;
28397   result = (int) ((arg1)->direction);
28398   jresult = result;
28399   return jresult;
28400 }
28401
28402
28403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28404   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28405   unsigned int arg2 ;
28406
28407   arg1 = (Dali::WheelEvent *)jarg1;
28408   arg2 = (unsigned int)jarg2;
28409   if (arg1) (arg1)->modifiers = arg2;
28410 }
28411
28412
28413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28414   unsigned int jresult ;
28415   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28416   unsigned int result;
28417
28418   arg1 = (Dali::WheelEvent *)jarg1;
28419   result = (unsigned int) ((arg1)->modifiers);
28420   jresult = result;
28421   return jresult;
28422 }
28423
28424
28425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28426   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28427   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28428
28429   arg1 = (Dali::WheelEvent *)jarg1;
28430   arg2 = (Dali::Vector2 *)jarg2;
28431   if (arg1) (arg1)->point = *arg2;
28432 }
28433
28434
28435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28436   void * jresult ;
28437   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28438   Dali::Vector2 *result = 0 ;
28439
28440   arg1 = (Dali::WheelEvent *)jarg1;
28441   result = (Dali::Vector2 *)& ((arg1)->point);
28442   jresult = (void *)result;
28443   return jresult;
28444 }
28445
28446
28447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28448   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28449   int arg2 ;
28450
28451   arg1 = (Dali::WheelEvent *)jarg1;
28452   arg2 = (int)jarg2;
28453   if (arg1) (arg1)->z = arg2;
28454 }
28455
28456
28457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28458   int jresult ;
28459   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28460   int result;
28461
28462   arg1 = (Dali::WheelEvent *)jarg1;
28463   result = (int) ((arg1)->z);
28464   jresult = result;
28465   return jresult;
28466 }
28467
28468
28469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28470   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28471   unsigned int arg2 ;
28472
28473   arg1 = (Dali::WheelEvent *)jarg1;
28474   arg2 = (unsigned int)jarg2;
28475   if (arg1) (arg1)->timeStamp = arg2;
28476 }
28477
28478
28479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28480   unsigned int jresult ;
28481   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28482   unsigned int result;
28483
28484   arg1 = (Dali::WheelEvent *)jarg1;
28485   result = (unsigned int) ((arg1)->timeStamp);
28486   jresult = result;
28487   return jresult;
28488 }
28489
28490 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28491   char * jresult ;
28492   Dali::KeyEvent *arg1 = 0 ;
28493   std::string result;
28494
28495   arg1 = (Dali::KeyEvent *)jarg1;
28496   if (!arg1) {
28497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28498     return 0;
28499   }
28500   {
28501     try {
28502       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28503     } catch (std::out_of_range& e) {
28504       {
28505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28506       };
28507     } catch (std::exception& e) {
28508       {
28509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28510       };
28511     } catch (...) {
28512       {
28513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28514       };
28515     }
28516   }
28517   jresult = SWIG_csharp_string_callback((&result)->c_str());
28518   return jresult;
28519 }
28520
28521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28522   int jresult ;
28523   Dali::KeyEvent *arg1 = 0 ;
28524   Dali::DevelKeyEvent::DeviceClass::Type result;
28525
28526   arg1 = (Dali::KeyEvent *)jarg1;
28527   if (!arg1) {
28528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28529     return 0;
28530   }
28531   {
28532     try {
28533       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28534     } catch (std::out_of_range& e) {
28535       {
28536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28537       };
28538     } catch (std::exception& e) {
28539       {
28540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28541       };
28542     } catch (...) {
28543       {
28544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28545       };
28546     }
28547   }
28548   jresult = (int)result;
28549   return jresult;
28550 }
28551
28552
28553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28554   Dali::Actor arg1 ;
28555   Dali::Actor *argp1 ;
28556
28557   argp1 = (Dali::Actor *)jarg1;
28558   if (!argp1) {
28559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28560     return ;
28561   }
28562   arg1 = *argp1;
28563   {
28564     try {
28565       Dali::DevelActor::Raise(arg1);
28566     } catch (std::out_of_range& e) {
28567       {
28568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28569       };
28570     } catch (std::exception& e) {
28571       {
28572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28573       };
28574     } catch (...) {
28575       {
28576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28577       };
28578     }
28579   }
28580 }
28581
28582
28583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28584   Dali::Actor arg1 ;
28585   Dali::Actor *argp1 ;
28586
28587   argp1 = (Dali::Actor *)jarg1;
28588   if (!argp1) {
28589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28590     return ;
28591   }
28592   arg1 = *argp1;
28593   {
28594     try {
28595       Dali::DevelActor::Lower(arg1);
28596     } catch (std::out_of_range& e) {
28597       {
28598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28599       };
28600     } catch (std::exception& e) {
28601       {
28602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28603       };
28604     } catch (...) {
28605       {
28606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28607       };
28608     }
28609   }
28610 }
28611
28612
28613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28614   Dali::Actor arg1 ;
28615   Dali::Actor *argp1 ;
28616
28617   argp1 = (Dali::Actor *)jarg1;
28618   if (!argp1) {
28619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28620     return ;
28621   }
28622   arg1 = *argp1;
28623   {
28624     try {
28625       Dali::DevelActor::RaiseToTop(arg1);
28626     } catch (std::out_of_range& e) {
28627       {
28628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28629       };
28630     } catch (std::exception& e) {
28631       {
28632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28633       };
28634     } catch (...) {
28635       {
28636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28637       };
28638     }
28639   }
28640 }
28641
28642
28643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28644   Dali::Actor arg1 ;
28645   Dali::Actor *argp1 ;
28646
28647   argp1 = (Dali::Actor *)jarg1;
28648   if (!argp1) {
28649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28650     return ;
28651   }
28652   arg1 = *argp1;
28653   {
28654     try {
28655       Dali::DevelActor::LowerToBottom(arg1);
28656     } catch (std::out_of_range& e) {
28657       {
28658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28659       };
28660     } catch (std::exception& e) {
28661       {
28662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28663       };
28664     } catch (...) {
28665       {
28666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28667       };
28668     }
28669   }
28670 }
28671
28672
28673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28674   Dali::Actor arg1 ;
28675   Dali::Actor arg2 ;
28676   Dali::Actor *argp1 ;
28677   Dali::Actor *argp2 ;
28678
28679   argp1 = (Dali::Actor *)jarg1;
28680   if (!argp1) {
28681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28682     return ;
28683   }
28684   arg1 = *argp1;
28685   argp2 = (Dali::Actor *)jarg2;
28686   if (!argp2) {
28687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28688     return ;
28689   }
28690   arg2 = *argp2;
28691   {
28692     try {
28693       Dali::DevelActor::RaiseAbove(arg1,arg2);
28694     } catch (std::out_of_range& e) {
28695       {
28696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28697       };
28698     } catch (std::exception& e) {
28699       {
28700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28701       };
28702     } catch (...) {
28703       {
28704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28705       };
28706     }
28707   }
28708 }
28709
28710
28711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28712   Dali::Actor arg1 ;
28713   Dali::Actor arg2 ;
28714   Dali::Actor *argp1 ;
28715   Dali::Actor *argp2 ;
28716
28717   argp1 = (Dali::Actor *)jarg1;
28718   if (!argp1) {
28719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28720     return ;
28721   }
28722   arg1 = *argp1;
28723   argp2 = (Dali::Actor *)jarg2;
28724   if (!argp2) {
28725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28726     return ;
28727   }
28728   arg2 = *argp2;
28729   {
28730     try {
28731       Dali::DevelActor::LowerBelow(arg1,arg2);
28732     } catch (std::out_of_range& e) {
28733       {
28734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28735       };
28736     } catch (std::exception& e) {
28737       {
28738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28739       };
28740     } catch (...) {
28741       {
28742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28743       };
28744     }
28745   }
28746 }
28747
28748
28749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28750   void * jresult ;
28751   Dali::Actor arg1 ;
28752   Dali::Actor *argp1 ;
28753   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28754
28755   argp1 = (Dali::Actor *)jarg1;
28756   if (!argp1) {
28757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28758     return 0;
28759   }
28760   arg1 = *argp1;
28761   {
28762     try {
28763       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28764     } catch (std::out_of_range& e) {
28765       {
28766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28767       };
28768     } catch (std::exception& e) {
28769       {
28770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28771       };
28772     } catch (...) {
28773       {
28774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28775       };
28776     }
28777   }
28778   jresult = (void *)result;
28779   return jresult;
28780 }
28781
28782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28783   int jresult ;
28784   int result;
28785
28786   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28787   jresult = (int)result;
28788   return jresult;
28789 }
28790
28791
28792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28793   int jresult ;
28794   int result;
28795
28796   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28797   jresult = (int)result;
28798   return jresult;
28799 }
28800
28801
28802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28803   int jresult ;
28804   int result;
28805
28806   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28807   jresult = (int)result;
28808   return jresult;
28809 }
28810
28811
28812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28813   int jresult ;
28814   int result;
28815
28816   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28817   jresult = (int)result;
28818   return jresult;
28819 }
28820
28821
28822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28823   int jresult ;
28824   int result;
28825
28826   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28827   jresult = (int)result;
28828   return jresult;
28829 }
28830
28831
28832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28833   int jresult ;
28834   int result;
28835
28836   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28837   jresult = (int)result;
28838   return jresult;
28839 }
28840
28841
28842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28843   int jresult ;
28844   int result;
28845
28846   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28847   jresult = (int)result;
28848   return jresult;
28849 }
28850
28851
28852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28853   int jresult ;
28854   int result;
28855
28856   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28857   jresult = (int)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28863   int jresult ;
28864   int result;
28865
28866   result = (int)Dali::Actor::Property::SIZE;
28867   jresult = (int)result;
28868   return jresult;
28869 }
28870
28871
28872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28873   int jresult ;
28874   int result;
28875
28876   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28877   jresult = (int)result;
28878   return jresult;
28879 }
28880
28881
28882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28883   int jresult ;
28884   int result;
28885
28886   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28887   jresult = (int)result;
28888   return jresult;
28889 }
28890
28891
28892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28893   int jresult ;
28894   int result;
28895
28896   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28897   jresult = (int)result;
28898   return jresult;
28899 }
28900
28901
28902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28903   int jresult ;
28904   int result;
28905
28906   result = (int)Dali::Actor::Property::POSITION;
28907   jresult = (int)result;
28908   return jresult;
28909 }
28910
28911
28912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28913   int jresult ;
28914   int result;
28915
28916   result = (int)Dali::Actor::Property::POSITION_X;
28917   jresult = (int)result;
28918   return jresult;
28919 }
28920
28921
28922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28923   int jresult ;
28924   int result;
28925
28926   result = (int)Dali::Actor::Property::POSITION_Y;
28927   jresult = (int)result;
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28933   int jresult ;
28934   int result;
28935
28936   result = (int)Dali::Actor::Property::POSITION_Z;
28937   jresult = (int)result;
28938   return jresult;
28939 }
28940
28941
28942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28943   int jresult ;
28944   int result;
28945
28946   result = (int)Dali::Actor::Property::WORLD_POSITION;
28947   jresult = (int)result;
28948   return jresult;
28949 }
28950
28951
28952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28953   int jresult ;
28954   int result;
28955
28956   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28957   jresult = (int)result;
28958   return jresult;
28959 }
28960
28961
28962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28963   int jresult ;
28964   int result;
28965
28966   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28967   jresult = (int)result;
28968   return jresult;
28969 }
28970
28971
28972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28973   int jresult ;
28974   int result;
28975
28976   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28977   jresult = (int)result;
28978   return jresult;
28979 }
28980
28981
28982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28983   int jresult ;
28984   int result;
28985
28986   result = (int)Dali::Actor::Property::ORIENTATION;
28987   jresult = (int)result;
28988   return jresult;
28989 }
28990
28991
28992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28993   int jresult ;
28994   int result;
28995
28996   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28997   jresult = (int)result;
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29003   int jresult ;
29004   int result;
29005
29006   result = (int)Dali::Actor::Property::SCALE;
29007   jresult = (int)result;
29008   return jresult;
29009 }
29010
29011
29012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29013   int jresult ;
29014   int result;
29015
29016   result = (int)Dali::Actor::Property::SCALE_X;
29017   jresult = (int)result;
29018   return jresult;
29019 }
29020
29021
29022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29023   int jresult ;
29024   int result;
29025
29026   result = (int)Dali::Actor::Property::SCALE_Y;
29027   jresult = (int)result;
29028   return jresult;
29029 }
29030
29031
29032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29033   int jresult ;
29034   int result;
29035
29036   result = (int)Dali::Actor::Property::SCALE_Z;
29037   jresult = (int)result;
29038   return jresult;
29039 }
29040
29041
29042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29043   int jresult ;
29044   int result;
29045
29046   result = (int)Dali::Actor::Property::WORLD_SCALE;
29047   jresult = (int)result;
29048   return jresult;
29049 }
29050
29051
29052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29053   int jresult ;
29054   int result;
29055
29056   result = (int)Dali::Actor::Property::VISIBLE;
29057   jresult = (int)result;
29058   return jresult;
29059 }
29060
29061
29062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29063   int jresult ;
29064   int result;
29065
29066   result = (int)Dali::Actor::Property::COLOR;
29067   jresult = (int)result;
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29073   int jresult ;
29074   int result;
29075
29076   result = (int)Dali::Actor::Property::COLOR_RED;
29077   jresult = (int)result;
29078   return jresult;
29079 }
29080
29081
29082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29083   int jresult ;
29084   int result;
29085
29086   result = (int)Dali::Actor::Property::COLOR_GREEN;
29087   jresult = (int)result;
29088   return jresult;
29089 }
29090
29091
29092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29093   int jresult ;
29094   int result;
29095
29096   result = (int)Dali::Actor::Property::COLOR_BLUE;
29097   jresult = (int)result;
29098   return jresult;
29099 }
29100
29101
29102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29103   int jresult ;
29104   int result;
29105
29106   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29107   jresult = (int)result;
29108   return jresult;
29109 }
29110
29111
29112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29113   int jresult ;
29114   int result;
29115
29116   result = (int)Dali::Actor::Property::WORLD_COLOR;
29117   jresult = (int)result;
29118   return jresult;
29119 }
29120
29121
29122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29123   int jresult ;
29124   int result;
29125
29126   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29127   jresult = (int)result;
29128   return jresult;
29129 }
29130
29131
29132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29133   int jresult ;
29134   int result;
29135
29136   result = (int)Dali::Actor::Property::NAME;
29137   jresult = (int)result;
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29143   int jresult ;
29144   int result;
29145
29146   result = (int)Dali::Actor::Property::SENSITIVE;
29147   jresult = (int)result;
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29153   int jresult ;
29154   int result;
29155
29156   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29157   jresult = (int)result;
29158   return jresult;
29159 }
29160
29161
29162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29163   int jresult ;
29164   int result;
29165
29166   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29167   jresult = (int)result;
29168   return jresult;
29169 }
29170
29171
29172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29173   int jresult ;
29174   int result;
29175
29176   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29177   jresult = (int)result;
29178   return jresult;
29179 }
29180
29181
29182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29183   int jresult ;
29184   int result;
29185
29186   result = (int)Dali::Actor::Property::COLOR_MODE;
29187   jresult = (int)result;
29188   return jresult;
29189 }
29190
29191
29192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29193   int jresult ;
29194   int result;
29195
29196   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29197   jresult = (int)result;
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29203   int jresult ;
29204   int result;
29205
29206   result = (int)Dali::Actor::Property::DRAW_MODE;
29207   jresult = (int)result;
29208   return jresult;
29209 }
29210
29211
29212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29213   int jresult ;
29214   int result;
29215
29216   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29217   jresult = (int)result;
29218   return jresult;
29219 }
29220
29221
29222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29223   int jresult ;
29224   int result;
29225
29226   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29227   jresult = (int)result;
29228   return jresult;
29229 }
29230
29231
29232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29233   int jresult ;
29234   int result;
29235
29236   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29237   jresult = (int)result;
29238   return jresult;
29239 }
29240
29241
29242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29243   int jresult ;
29244   int result;
29245
29246   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29247   jresult = (int)result;
29248   return jresult;
29249 }
29250
29251
29252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29253   int jresult ;
29254   int result;
29255
29256   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29257   jresult = (int)result;
29258   return jresult;
29259 }
29260
29261
29262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29263   int jresult ;
29264   int result;
29265
29266   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29267   jresult = (int)result;
29268   return jresult;
29269 }
29270
29271
29272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29273   int jresult ;
29274   int result;
29275
29276   result = (int)Dali::Actor::Property::PADDING;
29277   jresult = (int)result;
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29283   int jresult ;
29284   int result;
29285
29286   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29287   jresult = (int)result;
29288   return jresult;
29289 }
29290
29291
29292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29293   int jresult ;
29294   int result;
29295
29296   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29297   jresult = (int)result;
29298   return jresult;
29299 }
29300
29301
29302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29303   int jresult ;
29304   int result;
29305
29306   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29307   jresult = (int)result;
29308   return jresult;
29309 }
29310
29311
29312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29313   int jresult ;
29314   int result;
29315
29316   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29317   jresult = (int)result;
29318   return jresult;
29319 }
29320
29321
29322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29323   void * jresult ;
29324   Dali::Actor::Property *result = 0 ;
29325
29326   {
29327     try {
29328       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29329     } catch (std::out_of_range& e) {
29330       {
29331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (std::exception& e) {
29334       {
29335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29340       };
29341     }
29342   }
29343   jresult = (void *)result;
29344   return jresult;
29345 }
29346
29347
29348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29349   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29350
29351   arg1 = (Dali::Actor::Property *)jarg1;
29352   {
29353     try {
29354       delete arg1;
29355     } catch (std::out_of_range& e) {
29356       {
29357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29358       };
29359     } catch (std::exception& e) {
29360       {
29361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29362       };
29363     } catch (...) {
29364       {
29365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29366       };
29367     }
29368   }
29369 }
29370
29371
29372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29373   void * jresult ;
29374   Dali::Actor *result = 0 ;
29375
29376   {
29377     try {
29378       result = (Dali::Actor *)new Dali::Actor();
29379     } catch (std::out_of_range& e) {
29380       {
29381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29382       };
29383     } catch (std::exception& e) {
29384       {
29385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29386       };
29387     } catch (...) {
29388       {
29389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29390       };
29391     }
29392   }
29393   jresult = (void *)result;
29394   return jresult;
29395 }
29396
29397
29398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29399   void * jresult ;
29400   Dali::Actor result;
29401
29402   {
29403     try {
29404       result = Dali::Actor::New();
29405     } catch (std::out_of_range& e) {
29406       {
29407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29408       };
29409     } catch (std::exception& e) {
29410       {
29411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29412       };
29413     } catch (...) {
29414       {
29415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29416       };
29417     }
29418   }
29419   jresult = new Dali::Actor((const Dali::Actor &)result);
29420   return jresult;
29421 }
29422
29423
29424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29425   void * jresult ;
29426   Dali::BaseHandle arg1 ;
29427   Dali::BaseHandle *argp1 ;
29428   Dali::Actor result;
29429
29430   argp1 = (Dali::BaseHandle *)jarg1;
29431   if (!argp1) {
29432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29433     return 0;
29434   }
29435   arg1 = *argp1;
29436   {
29437     try {
29438       result = Dali::Actor::DownCast(arg1);
29439     } catch (std::out_of_range& e) {
29440       {
29441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29442       };
29443     } catch (std::exception& e) {
29444       {
29445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29446       };
29447     } catch (...) {
29448       {
29449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29450       };
29451     }
29452   }
29453   jresult = new Dali::Actor((const Dali::Actor &)result);
29454   return jresult;
29455 }
29456
29457
29458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29460
29461   arg1 = (Dali::Actor *)jarg1;
29462   {
29463     try {
29464       delete arg1;
29465     } catch (std::out_of_range& e) {
29466       {
29467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29468       };
29469     } catch (std::exception& e) {
29470       {
29471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29472       };
29473     } catch (...) {
29474       {
29475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29476       };
29477     }
29478   }
29479 }
29480
29481
29482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29483   void * jresult ;
29484   Dali::Actor *arg1 = 0 ;
29485   Dali::Actor *result = 0 ;
29486
29487   arg1 = (Dali::Actor *)jarg1;
29488   if (!arg1) {
29489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29490     return 0;
29491   }
29492   {
29493     try {
29494       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29495     } catch (std::out_of_range& e) {
29496       {
29497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29498       };
29499     } catch (std::exception& e) {
29500       {
29501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29502       };
29503     } catch (...) {
29504       {
29505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29506       };
29507     }
29508   }
29509   jresult = (void *)result;
29510   return jresult;
29511 }
29512
29513
29514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29515   void * jresult ;
29516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29517   Dali::Actor *arg2 = 0 ;
29518   Dali::Actor *result = 0 ;
29519
29520   arg1 = (Dali::Actor *)jarg1;
29521   arg2 = (Dali::Actor *)jarg2;
29522   if (!arg2) {
29523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29524     return 0;
29525   }
29526   {
29527     try {
29528       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29529     } catch (std::out_of_range& e) {
29530       {
29531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29532       };
29533     } catch (std::exception& e) {
29534       {
29535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29536       };
29537     } catch (...) {
29538       {
29539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29540       };
29541     }
29542   }
29543   jresult = (void *)result;
29544   return jresult;
29545 }
29546
29547
29548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29549   char * jresult ;
29550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29551   std::string *result = 0 ;
29552
29553   arg1 = (Dali::Actor *)jarg1;
29554   {
29555     try {
29556       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29557     } catch (std::out_of_range& e) {
29558       {
29559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29560       };
29561     } catch (std::exception& e) {
29562       {
29563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29564       };
29565     } catch (...) {
29566       {
29567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29568       };
29569     }
29570   }
29571   jresult = SWIG_csharp_string_callback(result->c_str());
29572   return jresult;
29573 }
29574
29575
29576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29577   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29578   std::string *arg2 = 0 ;
29579
29580   arg1 = (Dali::Actor *)jarg1;
29581   if (!jarg2) {
29582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29583     return ;
29584   }
29585   std::string arg2_str(jarg2);
29586   arg2 = &arg2_str;
29587   {
29588     try {
29589       (arg1)->SetName((std::string const &)*arg2);
29590     } catch (std::out_of_range& e) {
29591       {
29592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29593       };
29594     } catch (std::exception& e) {
29595       {
29596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29597       };
29598     } catch (...) {
29599       {
29600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29601       };
29602     }
29603   }
29604
29605   //argout typemap for const std::string&
29606
29607 }
29608
29609
29610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29611   unsigned int jresult ;
29612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29613   unsigned int result;
29614
29615   arg1 = (Dali::Actor *)jarg1;
29616   {
29617     try {
29618       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29619     } catch (std::out_of_range& e) {
29620       {
29621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29622       };
29623     } catch (std::exception& e) {
29624       {
29625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29626       };
29627     } catch (...) {
29628       {
29629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29630       };
29631     }
29632   }
29633   jresult = result;
29634   return jresult;
29635 }
29636
29637
29638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29639   unsigned int jresult ;
29640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29641   bool result;
29642
29643   arg1 = (Dali::Actor *)jarg1;
29644   {
29645     try {
29646       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29647     } catch (std::out_of_range& e) {
29648       {
29649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29650       };
29651     } catch (std::exception& e) {
29652       {
29653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29654       };
29655     } catch (...) {
29656       {
29657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29658       };
29659     }
29660   }
29661   jresult = result;
29662   return jresult;
29663 }
29664
29665
29666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29667   unsigned int jresult ;
29668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29669   bool result;
29670
29671   arg1 = (Dali::Actor *)jarg1;
29672   {
29673     try {
29674       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29675     } catch (std::out_of_range& e) {
29676       {
29677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29678       };
29679     } catch (std::exception& e) {
29680       {
29681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29682       };
29683     } catch (...) {
29684       {
29685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29686       };
29687     }
29688   }
29689   jresult = result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29695   unsigned int jresult ;
29696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29697   bool result;
29698
29699   arg1 = (Dali::Actor *)jarg1;
29700   {
29701     try {
29702       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29703     } catch (std::out_of_range& e) {
29704       {
29705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29706       };
29707     } catch (std::exception& e) {
29708       {
29709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (...) {
29712       {
29713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29714       };
29715     }
29716   }
29717   jresult = result;
29718   return jresult;
29719 }
29720
29721
29722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29723   void * jresult ;
29724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29725   Dali::Layer result;
29726
29727   arg1 = (Dali::Actor *)jarg1;
29728   {
29729     try {
29730       result = (arg1)->GetLayer();
29731     } catch (std::out_of_range& e) {
29732       {
29733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29734       };
29735     } catch (std::exception& e) {
29736       {
29737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29738       };
29739     } catch (...) {
29740       {
29741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29742       };
29743     }
29744   }
29745   jresult = new Dali::Layer((const Dali::Layer &)result);
29746   return jresult;
29747 }
29748
29749
29750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29751   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29752   Dali::Actor arg2 ;
29753   Dali::Actor *argp2 ;
29754
29755   arg1 = (Dali::Actor *)jarg1;
29756   argp2 = (Dali::Actor *)jarg2;
29757   if (!argp2) {
29758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29759     return ;
29760   }
29761   arg2 = *argp2;
29762   {
29763     try {
29764       (arg1)->Add(arg2);
29765     } catch (std::out_of_range& e) {
29766       {
29767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29768       };
29769     } catch (std::exception& e) {
29770       {
29771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29772       };
29773     } catch (...) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29776       };
29777     }
29778   }
29779 }
29780
29781
29782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29784   Dali::Actor arg2 ;
29785   Dali::Actor *argp2 ;
29786
29787   arg1 = (Dali::Actor *)jarg1;
29788   argp2 = (Dali::Actor *)jarg2;
29789   if (!argp2) {
29790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29791     return ;
29792   }
29793   arg2 = *argp2;
29794   {
29795     try {
29796       (arg1)->Remove(arg2);
29797     } catch (std::out_of_range& e) {
29798       {
29799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29800       };
29801     } catch (std::exception& e) {
29802       {
29803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29804       };
29805     } catch (...) {
29806       {
29807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29808       };
29809     }
29810   }
29811 }
29812
29813
29814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29816
29817   arg1 = (Dali::Actor *)jarg1;
29818   {
29819     try {
29820       (arg1)->Unparent();
29821     } catch (std::out_of_range& e) {
29822       {
29823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29824       };
29825     } catch (std::exception& e) {
29826       {
29827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29828       };
29829     } catch (...) {
29830       {
29831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29832       };
29833     }
29834   }
29835 }
29836
29837
29838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29839   unsigned int jresult ;
29840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29841   unsigned int result;
29842
29843   arg1 = (Dali::Actor *)jarg1;
29844   {
29845     try {
29846       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29847     } catch (std::out_of_range& e) {
29848       {
29849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (std::exception& e) {
29852       {
29853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861   jresult = result;
29862   return jresult;
29863 }
29864
29865
29866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29867   void * jresult ;
29868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29869   unsigned int arg2 ;
29870   Dali::Actor result;
29871
29872   arg1 = (Dali::Actor *)jarg1;
29873   arg2 = (unsigned int)jarg2;
29874   {
29875     try {
29876       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29877     } catch (std::out_of_range& e) {
29878       {
29879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29880       };
29881     } catch (std::exception& e) {
29882       {
29883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29884       };
29885     } catch (...) {
29886       {
29887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29888       };
29889     }
29890   }
29891   jresult = new Dali::Actor((const Dali::Actor &)result);
29892   return jresult;
29893 }
29894
29895
29896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29897   void * jresult ;
29898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29899   std::string *arg2 = 0 ;
29900   Dali::Actor result;
29901
29902   arg1 = (Dali::Actor *)jarg1;
29903   if (!jarg2) {
29904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29905     return 0;
29906   }
29907   std::string arg2_str(jarg2);
29908   arg2 = &arg2_str;
29909   {
29910     try {
29911       result = (arg1)->FindChildByName((std::string const &)*arg2);
29912     } catch (std::out_of_range& e) {
29913       {
29914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29915       };
29916     } catch (std::exception& e) {
29917       {
29918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29919       };
29920     } catch (...) {
29921       {
29922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29923       };
29924     }
29925   }
29926   jresult = new Dali::Actor((const Dali::Actor &)result);
29927
29928   //argout typemap for const std::string&
29929
29930   return jresult;
29931 }
29932
29933
29934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29935   void * jresult ;
29936   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29937   unsigned int arg2 ;
29938   Dali::Actor result;
29939
29940   arg1 = (Dali::Actor *)jarg1;
29941   arg2 = (unsigned int)jarg2;
29942   {
29943     try {
29944       result = (arg1)->FindChildById(arg2);
29945     } catch (std::out_of_range& e) {
29946       {
29947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29948       };
29949     } catch (std::exception& e) {
29950       {
29951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29952       };
29953     } catch (...) {
29954       {
29955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29956       };
29957     }
29958   }
29959   jresult = new Dali::Actor((const Dali::Actor &)result);
29960   return jresult;
29961 }
29962
29963
29964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29965   void * jresult ;
29966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29967   Dali::Actor result;
29968
29969   arg1 = (Dali::Actor *)jarg1;
29970   {
29971     try {
29972       result = ((Dali::Actor const *)arg1)->GetParent();
29973     } catch (std::out_of_range& e) {
29974       {
29975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29976       };
29977     } catch (std::exception& e) {
29978       {
29979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (...) {
29982       {
29983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29984       };
29985     }
29986   }
29987   jresult = new Dali::Actor((const Dali::Actor &)result);
29988   return jresult;
29989 }
29990
29991
29992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29994   Dali::Vector3 *arg2 = 0 ;
29995
29996   arg1 = (Dali::Actor *)jarg1;
29997   arg2 = (Dali::Vector3 *)jarg2;
29998   if (!arg2) {
29999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30000     return ;
30001   }
30002   {
30003     try {
30004       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30005     } catch (std::out_of_range& e) {
30006       {
30007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30008       };
30009     } catch (std::exception& e) {
30010       {
30011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30012       };
30013     } catch (...) {
30014       {
30015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30016       };
30017     }
30018   }
30019 }
30020
30021
30022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30023   void * jresult ;
30024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30025   Dali::Vector3 result;
30026
30027   arg1 = (Dali::Actor *)jarg1;
30028   {
30029     try {
30030       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (...) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30042       };
30043     }
30044   }
30045   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30046   return jresult;
30047 }
30048
30049
30050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30052   Dali::Vector3 *arg2 = 0 ;
30053
30054   arg1 = (Dali::Actor *)jarg1;
30055   arg2 = (Dali::Vector3 *)jarg2;
30056   if (!arg2) {
30057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30058     return ;
30059   }
30060   {
30061     try {
30062       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30063     } catch (std::out_of_range& e) {
30064       {
30065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30066       };
30067     } catch (std::exception& e) {
30068       {
30069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30070       };
30071     } catch (...) {
30072       {
30073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30074       };
30075     }
30076   }
30077 }
30078
30079
30080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30081   void * jresult ;
30082   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30083   Dali::Vector3 result;
30084
30085   arg1 = (Dali::Actor *)jarg1;
30086   {
30087     try {
30088       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30089     } catch (std::out_of_range& e) {
30090       {
30091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30092       };
30093     } catch (std::exception& e) {
30094       {
30095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30096       };
30097     } catch (...) {
30098       {
30099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30100       };
30101     }
30102   }
30103   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30104   return jresult;
30105 }
30106
30107
30108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30109   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30110   float arg2 ;
30111   float arg3 ;
30112
30113   arg1 = (Dali::Actor *)jarg1;
30114   arg2 = (float)jarg2;
30115   arg3 = (float)jarg3;
30116   {
30117     try {
30118       (arg1)->SetSize(arg2,arg3);
30119     } catch (std::out_of_range& e) {
30120       {
30121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30122       };
30123     } catch (std::exception& e) {
30124       {
30125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30126       };
30127     } catch (...) {
30128       {
30129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30130       };
30131     }
30132   }
30133 }
30134
30135
30136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30138   float arg2 ;
30139   float arg3 ;
30140   float arg4 ;
30141
30142   arg1 = (Dali::Actor *)jarg1;
30143   arg2 = (float)jarg2;
30144   arg3 = (float)jarg3;
30145   arg4 = (float)jarg4;
30146   {
30147     try {
30148       (arg1)->SetSize(arg2,arg3,arg4);
30149     } catch (std::out_of_range& e) {
30150       {
30151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30152       };
30153     } catch (std::exception& e) {
30154       {
30155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30156       };
30157     } catch (...) {
30158       {
30159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30160       };
30161     }
30162   }
30163 }
30164
30165
30166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30168   Dali::Vector2 *arg2 = 0 ;
30169
30170   arg1 = (Dali::Actor *)jarg1;
30171   arg2 = (Dali::Vector2 *)jarg2;
30172   if (!arg2) {
30173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30174     return ;
30175   }
30176   {
30177     try {
30178       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30179     } catch (std::out_of_range& e) {
30180       {
30181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30182       };
30183     } catch (std::exception& e) {
30184       {
30185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30186       };
30187     } catch (...) {
30188       {
30189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30190       };
30191     }
30192   }
30193 }
30194
30195
30196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30198   Dali::Vector3 *arg2 = 0 ;
30199
30200   arg1 = (Dali::Actor *)jarg1;
30201   arg2 = (Dali::Vector3 *)jarg2;
30202   if (!arg2) {
30203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30204     return ;
30205   }
30206   {
30207     try {
30208       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30209     } catch (std::out_of_range& e) {
30210       {
30211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30212       };
30213     } catch (std::exception& e) {
30214       {
30215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30216       };
30217     } catch (...) {
30218       {
30219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30220       };
30221     }
30222   }
30223 }
30224
30225
30226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30227   void * jresult ;
30228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30229   Dali::Vector3 result;
30230
30231   arg1 = (Dali::Actor *)jarg1;
30232   {
30233     try {
30234       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30235     } catch (std::out_of_range& e) {
30236       {
30237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30238       };
30239     } catch (std::exception& e) {
30240       {
30241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30242       };
30243     } catch (...) {
30244       {
30245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30246       };
30247     }
30248   }
30249   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30250   return jresult;
30251 }
30252
30253
30254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30255   void * jresult ;
30256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30257   Dali::Vector3 result;
30258
30259   arg1 = (Dali::Actor *)jarg1;
30260   {
30261     try {
30262       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30263     } catch (std::out_of_range& e) {
30264       {
30265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30266       };
30267     } catch (std::exception& e) {
30268       {
30269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30270       };
30271     } catch (...) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30274       };
30275     }
30276   }
30277   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30278   return jresult;
30279 }
30280
30281
30282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30283   void * jresult ;
30284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30285   Dali::Vector3 result;
30286
30287   arg1 = (Dali::Actor *)jarg1;
30288   {
30289     try {
30290       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30291     } catch (std::out_of_range& e) {
30292       {
30293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30294       };
30295     } catch (std::exception& e) {
30296       {
30297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (...) {
30300       {
30301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30302       };
30303     }
30304   }
30305   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30306   return jresult;
30307 }
30308
30309
30310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30312   float arg2 ;
30313   float arg3 ;
30314
30315   arg1 = (Dali::Actor *)jarg1;
30316   arg2 = (float)jarg2;
30317   arg3 = (float)jarg3;
30318   {
30319     try {
30320       (arg1)->SetPosition(arg2,arg3);
30321     } catch (std::out_of_range& e) {
30322       {
30323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30324       };
30325     } catch (std::exception& e) {
30326       {
30327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30328       };
30329     } catch (...) {
30330       {
30331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30332       };
30333     }
30334   }
30335 }
30336
30337
30338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30340   float arg2 ;
30341   float arg3 ;
30342   float arg4 ;
30343
30344   arg1 = (Dali::Actor *)jarg1;
30345   arg2 = (float)jarg2;
30346   arg3 = (float)jarg3;
30347   arg4 = (float)jarg4;
30348   {
30349     try {
30350       (arg1)->SetPosition(arg2,arg3,arg4);
30351     } catch (std::out_of_range& e) {
30352       {
30353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30354       };
30355     } catch (std::exception& e) {
30356       {
30357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30358       };
30359     } catch (...) {
30360       {
30361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30362       };
30363     }
30364   }
30365 }
30366
30367
30368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30369   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30370   Dali::Vector3 *arg2 = 0 ;
30371
30372   arg1 = (Dali::Actor *)jarg1;
30373   arg2 = (Dali::Vector3 *)jarg2;
30374   if (!arg2) {
30375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30376     return ;
30377   }
30378   {
30379     try {
30380       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30381     } catch (std::out_of_range& e) {
30382       {
30383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (std::exception& e) {
30386       {
30387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30392       };
30393     }
30394   }
30395 }
30396
30397
30398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30400   float arg2 ;
30401
30402   arg1 = (Dali::Actor *)jarg1;
30403   arg2 = (float)jarg2;
30404   {
30405     try {
30406       (arg1)->SetX(arg2);
30407     } catch (std::out_of_range& e) {
30408       {
30409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30410       };
30411     } catch (std::exception& e) {
30412       {
30413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30414       };
30415     } catch (...) {
30416       {
30417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30418       };
30419     }
30420   }
30421 }
30422
30423
30424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30426   float arg2 ;
30427
30428   arg1 = (Dali::Actor *)jarg1;
30429   arg2 = (float)jarg2;
30430   {
30431     try {
30432       (arg1)->SetY(arg2);
30433     } catch (std::out_of_range& e) {
30434       {
30435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30436       };
30437     } catch (std::exception& e) {
30438       {
30439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (...) {
30442       {
30443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30444       };
30445     }
30446   }
30447 }
30448
30449
30450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30452   float arg2 ;
30453
30454   arg1 = (Dali::Actor *)jarg1;
30455   arg2 = (float)jarg2;
30456   {
30457     try {
30458       (arg1)->SetZ(arg2);
30459     } catch (std::out_of_range& e) {
30460       {
30461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30462       };
30463     } catch (std::exception& e) {
30464       {
30465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30466       };
30467     } catch (...) {
30468       {
30469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30470       };
30471     }
30472   }
30473 }
30474
30475
30476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30478   Dali::Vector3 *arg2 = 0 ;
30479
30480   arg1 = (Dali::Actor *)jarg1;
30481   arg2 = (Dali::Vector3 *)jarg2;
30482   if (!arg2) {
30483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30484     return ;
30485   }
30486   {
30487     try {
30488       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30489     } catch (std::out_of_range& e) {
30490       {
30491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30492       };
30493     } catch (std::exception& e) {
30494       {
30495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30496       };
30497     } catch (...) {
30498       {
30499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30500       };
30501     }
30502   }
30503 }
30504
30505
30506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30507   void * jresult ;
30508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30509   Dali::Vector3 result;
30510
30511   arg1 = (Dali::Actor *)jarg1;
30512   {
30513     try {
30514       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30515     } catch (std::out_of_range& e) {
30516       {
30517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30518       };
30519     } catch (std::exception& e) {
30520       {
30521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30522       };
30523     } catch (...) {
30524       {
30525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30526       };
30527     }
30528   }
30529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30530   return jresult;
30531 }
30532
30533
30534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30535   void * jresult ;
30536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30537   Dali::Vector3 result;
30538
30539   arg1 = (Dali::Actor *)jarg1;
30540   {
30541     try {
30542       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30543     } catch (std::out_of_range& e) {
30544       {
30545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30546       };
30547     } catch (std::exception& e) {
30548       {
30549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30550       };
30551     } catch (...) {
30552       {
30553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30554       };
30555     }
30556   }
30557   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30558   return jresult;
30559 }
30560
30561
30562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30564   bool arg2 ;
30565
30566   arg1 = (Dali::Actor *)jarg1;
30567   arg2 = jarg2 ? true : false;
30568   {
30569     try {
30570       (arg1)->SetInheritPosition(arg2);
30571     } catch (std::out_of_range& e) {
30572       {
30573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30574       };
30575     } catch (std::exception& e) {
30576       {
30577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30578       };
30579     } catch (...) {
30580       {
30581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30582       };
30583     }
30584   }
30585 }
30586
30587
30588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30589   int jresult ;
30590   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30591   Dali::PositionInheritanceMode result;
30592
30593   arg1 = (Dali::Actor *)jarg1;
30594   {
30595     try {
30596       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30597     } catch (std::out_of_range& e) {
30598       {
30599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30600       };
30601     } catch (std::exception& e) {
30602       {
30603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30604       };
30605     } catch (...) {
30606       {
30607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30608       };
30609     }
30610   }
30611   jresult = (int)result;
30612   return jresult;
30613 }
30614
30615
30616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30617   unsigned int jresult ;
30618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30619   bool result;
30620
30621   arg1 = (Dali::Actor *)jarg1;
30622   {
30623     try {
30624       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30625     } catch (std::out_of_range& e) {
30626       {
30627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30628       };
30629     } catch (std::exception& e) {
30630       {
30631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30632       };
30633     } catch (...) {
30634       {
30635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30636       };
30637     }
30638   }
30639   jresult = result;
30640   return jresult;
30641 }
30642
30643
30644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30646   Dali::Degree *arg2 = 0 ;
30647   Dali::Vector3 *arg3 = 0 ;
30648
30649   arg1 = (Dali::Actor *)jarg1;
30650   arg2 = (Dali::Degree *)jarg2;
30651   if (!arg2) {
30652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30653     return ;
30654   }
30655   arg3 = (Dali::Vector3 *)jarg3;
30656   if (!arg3) {
30657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30658     return ;
30659   }
30660   {
30661     try {
30662       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30663     } catch (std::out_of_range& e) {
30664       {
30665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30666       };
30667     } catch (std::exception& e) {
30668       {
30669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30674       };
30675     }
30676   }
30677 }
30678
30679
30680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30682   Dali::Radian *arg2 = 0 ;
30683   Dali::Vector3 *arg3 = 0 ;
30684
30685   arg1 = (Dali::Actor *)jarg1;
30686   arg2 = (Dali::Radian *)jarg2;
30687   if (!arg2) {
30688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30689     return ;
30690   }
30691   arg3 = (Dali::Vector3 *)jarg3;
30692   if (!arg3) {
30693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30694     return ;
30695   }
30696   {
30697     try {
30698       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30699     } catch (std::out_of_range& e) {
30700       {
30701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30702       };
30703     } catch (std::exception& e) {
30704       {
30705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30706       };
30707     } catch (...) {
30708       {
30709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30710       };
30711     }
30712   }
30713 }
30714
30715
30716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30718   Dali::Quaternion *arg2 = 0 ;
30719
30720   arg1 = (Dali::Actor *)jarg1;
30721   arg2 = (Dali::Quaternion *)jarg2;
30722   if (!arg2) {
30723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30724     return ;
30725   }
30726   {
30727     try {
30728       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (...) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30740       };
30741     }
30742   }
30743 }
30744
30745
30746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30747   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30748   Dali::Degree *arg2 = 0 ;
30749   Dali::Vector3 *arg3 = 0 ;
30750
30751   arg1 = (Dali::Actor *)jarg1;
30752   arg2 = (Dali::Degree *)jarg2;
30753   if (!arg2) {
30754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30755     return ;
30756   }
30757   arg3 = (Dali::Vector3 *)jarg3;
30758   if (!arg3) {
30759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30760     return ;
30761   }
30762   {
30763     try {
30764       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30765     } catch (std::out_of_range& e) {
30766       {
30767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30768       };
30769     } catch (std::exception& e) {
30770       {
30771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30772       };
30773     } catch (...) {
30774       {
30775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30776       };
30777     }
30778   }
30779 }
30780
30781
30782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30783   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30784   Dali::Radian *arg2 = 0 ;
30785   Dali::Vector3 *arg3 = 0 ;
30786
30787   arg1 = (Dali::Actor *)jarg1;
30788   arg2 = (Dali::Radian *)jarg2;
30789   if (!arg2) {
30790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30791     return ;
30792   }
30793   arg3 = (Dali::Vector3 *)jarg3;
30794   if (!arg3) {
30795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30796     return ;
30797   }
30798   {
30799     try {
30800       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30801     } catch (std::out_of_range& e) {
30802       {
30803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30804       };
30805     } catch (std::exception& e) {
30806       {
30807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30808       };
30809     } catch (...) {
30810       {
30811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30812       };
30813     }
30814   }
30815 }
30816
30817
30818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30820   Dali::Quaternion *arg2 = 0 ;
30821
30822   arg1 = (Dali::Actor *)jarg1;
30823   arg2 = (Dali::Quaternion *)jarg2;
30824   if (!arg2) {
30825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30826     return ;
30827   }
30828   {
30829     try {
30830       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30831     } catch (std::out_of_range& e) {
30832       {
30833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30834       };
30835     } catch (std::exception& e) {
30836       {
30837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (...) {
30840       {
30841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30842       };
30843     }
30844   }
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30849   void * jresult ;
30850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30851   Dali::Quaternion result;
30852
30853   arg1 = (Dali::Actor *)jarg1;
30854   {
30855     try {
30856       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (...) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30868       };
30869     }
30870   }
30871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30872   return jresult;
30873 }
30874
30875
30876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30878   bool arg2 ;
30879
30880   arg1 = (Dali::Actor *)jarg1;
30881   arg2 = jarg2 ? true : false;
30882   {
30883     try {
30884       (arg1)->SetInheritOrientation(arg2);
30885     } catch (std::out_of_range& e) {
30886       {
30887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30888       };
30889     } catch (std::exception& e) {
30890       {
30891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30892       };
30893     } catch (...) {
30894       {
30895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30896       };
30897     }
30898   }
30899 }
30900
30901
30902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30903   unsigned int jresult ;
30904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30905   bool result;
30906
30907   arg1 = (Dali::Actor *)jarg1;
30908   {
30909     try {
30910       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30911     } catch (std::out_of_range& e) {
30912       {
30913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30914       };
30915     } catch (std::exception& e) {
30916       {
30917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30918       };
30919     } catch (...) {
30920       {
30921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30922       };
30923     }
30924   }
30925   jresult = result;
30926   return jresult;
30927 }
30928
30929
30930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30931   void * jresult ;
30932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30933   Dali::Quaternion result;
30934
30935   arg1 = (Dali::Actor *)jarg1;
30936   {
30937     try {
30938       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30939     } catch (std::out_of_range& e) {
30940       {
30941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30942       };
30943     } catch (std::exception& e) {
30944       {
30945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30946       };
30947     } catch (...) {
30948       {
30949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30950       };
30951     }
30952   }
30953   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30954   return jresult;
30955 }
30956
30957
30958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30960   float arg2 ;
30961
30962   arg1 = (Dali::Actor *)jarg1;
30963   arg2 = (float)jarg2;
30964   {
30965     try {
30966       (arg1)->SetScale(arg2);
30967     } catch (std::out_of_range& e) {
30968       {
30969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30970       };
30971     } catch (std::exception& e) {
30972       {
30973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30978       };
30979     }
30980   }
30981 }
30982
30983
30984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30985   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30986   float arg2 ;
30987   float arg3 ;
30988   float arg4 ;
30989
30990   arg1 = (Dali::Actor *)jarg1;
30991   arg2 = (float)jarg2;
30992   arg3 = (float)jarg3;
30993   arg4 = (float)jarg4;
30994   {
30995     try {
30996       (arg1)->SetScale(arg2,arg3,arg4);
30997     } catch (std::out_of_range& e) {
30998       {
30999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31000       };
31001     } catch (std::exception& e) {
31002       {
31003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31004       };
31005     } catch (...) {
31006       {
31007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31008       };
31009     }
31010   }
31011 }
31012
31013
31014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31016   Dali::Vector3 *arg2 = 0 ;
31017
31018   arg1 = (Dali::Actor *)jarg1;
31019   arg2 = (Dali::Vector3 *)jarg2;
31020   if (!arg2) {
31021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31022     return ;
31023   }
31024   {
31025     try {
31026       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31034       };
31035     } catch (...) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31038       };
31039     }
31040   }
31041 }
31042
31043
31044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31046   Dali::Vector3 *arg2 = 0 ;
31047
31048   arg1 = (Dali::Actor *)jarg1;
31049   arg2 = (Dali::Vector3 *)jarg2;
31050   if (!arg2) {
31051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31052     return ;
31053   }
31054   {
31055     try {
31056       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31057     } catch (std::out_of_range& e) {
31058       {
31059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31060       };
31061     } catch (std::exception& e) {
31062       {
31063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31064       };
31065     } catch (...) {
31066       {
31067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31068       };
31069     }
31070   }
31071 }
31072
31073
31074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31075   void * jresult ;
31076   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31077   Dali::Vector3 result;
31078
31079   arg1 = (Dali::Actor *)jarg1;
31080   {
31081     try {
31082       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31083     } catch (std::out_of_range& e) {
31084       {
31085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31086       };
31087     } catch (std::exception& e) {
31088       {
31089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31090       };
31091     } catch (...) {
31092       {
31093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31094       };
31095     }
31096   }
31097   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31098   return jresult;
31099 }
31100
31101
31102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31103   void * jresult ;
31104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31105   Dali::Vector3 result;
31106
31107   arg1 = (Dali::Actor *)jarg1;
31108   {
31109     try {
31110       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31132   bool arg2 ;
31133
31134   arg1 = (Dali::Actor *)jarg1;
31135   arg2 = jarg2 ? true : false;
31136   {
31137     try {
31138       (arg1)->SetInheritScale(arg2);
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (...) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31150       };
31151     }
31152   }
31153 }
31154
31155
31156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31157   unsigned int jresult ;
31158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31159   bool result;
31160
31161   arg1 = (Dali::Actor *)jarg1;
31162   {
31163     try {
31164       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (...) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31176       };
31177     }
31178   }
31179   jresult = result;
31180   return jresult;
31181 }
31182
31183
31184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31185   void * jresult ;
31186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31187   Dali::Matrix result;
31188
31189   arg1 = (Dali::Actor *)jarg1;
31190   {
31191     try {
31192       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31193     } catch (std::out_of_range& e) {
31194       {
31195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31196       };
31197     } catch (std::exception& e) {
31198       {
31199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31200       };
31201     } catch (...) {
31202       {
31203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31204       };
31205     }
31206   }
31207   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31208   return jresult;
31209 }
31210
31211
31212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31214   bool arg2 ;
31215
31216   arg1 = (Dali::Actor *)jarg1;
31217   arg2 = jarg2 ? true : false;
31218   {
31219     try {
31220       (arg1)->SetVisible(arg2);
31221     } catch (std::out_of_range& e) {
31222       {
31223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31224       };
31225     } catch (std::exception& e) {
31226       {
31227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31228       };
31229     } catch (...) {
31230       {
31231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31232       };
31233     }
31234   }
31235 }
31236
31237
31238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31239   unsigned int jresult ;
31240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31241   bool result;
31242
31243   arg1 = (Dali::Actor *)jarg1;
31244   {
31245     try {
31246       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31247     } catch (std::out_of_range& e) {
31248       {
31249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31250       };
31251     } catch (std::exception& e) {
31252       {
31253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31254       };
31255     } catch (...) {
31256       {
31257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31258       };
31259     }
31260   }
31261   jresult = result;
31262   return jresult;
31263 }
31264
31265
31266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31268   float arg2 ;
31269
31270   arg1 = (Dali::Actor *)jarg1;
31271   arg2 = (float)jarg2;
31272   {
31273     try {
31274       (arg1)->SetOpacity(arg2);
31275     } catch (std::out_of_range& e) {
31276       {
31277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31278       };
31279     } catch (std::exception& e) {
31280       {
31281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31282       };
31283     } catch (...) {
31284       {
31285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31286       };
31287     }
31288   }
31289 }
31290
31291
31292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31293   float jresult ;
31294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31295   float result;
31296
31297   arg1 = (Dali::Actor *)jarg1;
31298   {
31299     try {
31300       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31301     } catch (std::out_of_range& e) {
31302       {
31303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (std::exception& e) {
31306       {
31307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31308       };
31309     } catch (...) {
31310       {
31311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31312       };
31313     }
31314   }
31315   jresult = result;
31316   return jresult;
31317 }
31318
31319
31320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31322   Dali::Vector4 *arg2 = 0 ;
31323
31324   arg1 = (Dali::Actor *)jarg1;
31325   arg2 = (Dali::Vector4 *)jarg2;
31326   if (!arg2) {
31327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31328     return ;
31329   }
31330   {
31331     try {
31332       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31333     } catch (std::out_of_range& e) {
31334       {
31335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31336       };
31337     } catch (std::exception& e) {
31338       {
31339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31340       };
31341     } catch (...) {
31342       {
31343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31344       };
31345     }
31346   }
31347 }
31348
31349
31350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31351   void * jresult ;
31352   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31353   Dali::Vector4 result;
31354
31355   arg1 = (Dali::Actor *)jarg1;
31356   {
31357     try {
31358       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31359     } catch (std::out_of_range& e) {
31360       {
31361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (std::exception& e) {
31364       {
31365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31366       };
31367     } catch (...) {
31368       {
31369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31370       };
31371     }
31372   }
31373   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31374   return jresult;
31375 }
31376
31377
31378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31380   Dali::ColorMode arg2 ;
31381
31382   arg1 = (Dali::Actor *)jarg1;
31383   arg2 = (Dali::ColorMode)jarg2;
31384   {
31385     try {
31386       (arg1)->SetColorMode(arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31398       };
31399     }
31400   }
31401 }
31402
31403
31404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31405   int jresult ;
31406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31407   Dali::ColorMode result;
31408
31409   arg1 = (Dali::Actor *)jarg1;
31410   {
31411     try {
31412       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31413     } catch (std::out_of_range& e) {
31414       {
31415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31416       };
31417     } catch (std::exception& e) {
31418       {
31419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31420       };
31421     } catch (...) {
31422       {
31423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31424       };
31425     }
31426   }
31427   jresult = (int)result;
31428   return jresult;
31429 }
31430
31431
31432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31433   void * jresult ;
31434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31435   Dali::Vector4 result;
31436
31437   arg1 = (Dali::Actor *)jarg1;
31438   {
31439     try {
31440       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31441     } catch (std::out_of_range& e) {
31442       {
31443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31444       };
31445     } catch (std::exception& e) {
31446       {
31447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31448       };
31449     } catch (...) {
31450       {
31451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31452       };
31453     }
31454   }
31455   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31456   return jresult;
31457 }
31458
31459
31460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31462   Dali::DrawMode::Type arg2 ;
31463
31464   arg1 = (Dali::Actor *)jarg1;
31465   arg2 = (Dali::DrawMode::Type)jarg2;
31466   {
31467     try {
31468       (arg1)->SetDrawMode(arg2);
31469     } catch (std::out_of_range& e) {
31470       {
31471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31472       };
31473     } catch (std::exception& e) {
31474       {
31475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31476       };
31477     } catch (...) {
31478       {
31479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31480       };
31481     }
31482   }
31483 }
31484
31485
31486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31487   int jresult ;
31488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31489   Dali::DrawMode::Type result;
31490
31491   arg1 = (Dali::Actor *)jarg1;
31492   {
31493     try {
31494       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31495     } catch (std::out_of_range& e) {
31496       {
31497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31498       };
31499     } catch (std::exception& e) {
31500       {
31501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31502       };
31503     } catch (...) {
31504       {
31505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31506       };
31507     }
31508   }
31509   jresult = (int)result;
31510   return jresult;
31511 }
31512
31513
31514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31516   bool arg2 ;
31517
31518   arg1 = (Dali::Actor *)jarg1;
31519   arg2 = jarg2 ? true : false;
31520   {
31521     try {
31522       (arg1)->SetSensitive(arg2);
31523     } catch (std::out_of_range& e) {
31524       {
31525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31526       };
31527     } catch (std::exception& e) {
31528       {
31529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31530       };
31531     } catch (...) {
31532       {
31533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31534       };
31535     }
31536   }
31537 }
31538
31539
31540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31541   unsigned int jresult ;
31542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31543   bool result;
31544
31545   arg1 = (Dali::Actor *)jarg1;
31546   {
31547     try {
31548       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31549     } catch (std::out_of_range& e) {
31550       {
31551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31552       };
31553     } catch (std::exception& e) {
31554       {
31555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (...) {
31558       {
31559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31560       };
31561     }
31562   }
31563   jresult = result;
31564   return jresult;
31565 }
31566
31567
31568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31569   unsigned int jresult ;
31570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31571   float *arg2 = 0 ;
31572   float *arg3 = 0 ;
31573   float arg4 ;
31574   float arg5 ;
31575   bool result;
31576
31577   arg1 = (Dali::Actor *)jarg1;
31578   arg2 = (float *)jarg2;
31579   arg3 = (float *)jarg3;
31580   arg4 = (float)jarg4;
31581   arg5 = (float)jarg5;
31582   {
31583     try {
31584       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31585     } catch (std::out_of_range& e) {
31586       {
31587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31588       };
31589     } catch (std::exception& e) {
31590       {
31591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31592       };
31593     } catch (...) {
31594       {
31595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31596       };
31597     }
31598   }
31599   jresult = result;
31600   return jresult;
31601 }
31602
31603
31604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31606   bool arg2 ;
31607
31608   arg1 = (Dali::Actor *)jarg1;
31609   arg2 = jarg2 ? true : false;
31610   {
31611     try {
31612       (arg1)->SetLeaveRequired(arg2);
31613     } catch (std::out_of_range& e) {
31614       {
31615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31616       };
31617     } catch (std::exception& e) {
31618       {
31619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31620       };
31621     } catch (...) {
31622       {
31623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31624       };
31625     }
31626   }
31627 }
31628
31629
31630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31631   unsigned int jresult ;
31632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31633   bool result;
31634
31635   arg1 = (Dali::Actor *)jarg1;
31636   {
31637     try {
31638       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31639     } catch (std::out_of_range& e) {
31640       {
31641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31642       };
31643     } catch (std::exception& e) {
31644       {
31645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31646       };
31647     } catch (...) {
31648       {
31649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31650       };
31651     }
31652   }
31653   jresult = result;
31654   return jresult;
31655 }
31656
31657
31658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31660   bool arg2 ;
31661
31662   arg1 = (Dali::Actor *)jarg1;
31663   arg2 = jarg2 ? true : false;
31664   {
31665     try {
31666       (arg1)->SetKeyboardFocusable(arg2);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31674       };
31675     } catch (...) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31678       };
31679     }
31680   }
31681 }
31682
31683
31684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31685   unsigned int jresult ;
31686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31687   bool result;
31688
31689   arg1 = (Dali::Actor *)jarg1;
31690   {
31691     try {
31692       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31693     } catch (std::out_of_range& e) {
31694       {
31695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (std::exception& e) {
31698       {
31699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31700       };
31701     } catch (...) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31704       };
31705     }
31706   }
31707   jresult = result;
31708   return jresult;
31709 }
31710
31711
31712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31714   Dali::ResizePolicy::Type arg2 ;
31715   Dali::Dimension::Type arg3 ;
31716
31717   arg1 = (Dali::Actor *)jarg1;
31718   arg2 = (Dali::ResizePolicy::Type)jarg2;
31719   arg3 = (Dali::Dimension::Type)jarg3;
31720   {
31721     try {
31722       (arg1)->SetResizePolicy(arg2,arg3);
31723     } catch (std::out_of_range& e) {
31724       {
31725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31726       };
31727     } catch (std::exception& e) {
31728       {
31729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31730       };
31731     } catch (...) {
31732       {
31733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31734       };
31735     }
31736   }
31737 }
31738
31739
31740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31741   int jresult ;
31742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31743   Dali::Dimension::Type arg2 ;
31744   Dali::ResizePolicy::Type result;
31745
31746   arg1 = (Dali::Actor *)jarg1;
31747   arg2 = (Dali::Dimension::Type)jarg2;
31748   {
31749     try {
31750       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31751     } catch (std::out_of_range& e) {
31752       {
31753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31754       };
31755     } catch (std::exception& e) {
31756       {
31757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (...) {
31760       {
31761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31762       };
31763     }
31764   }
31765   jresult = (int)result;
31766   return jresult;
31767 }
31768
31769
31770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31771   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31772   Dali::SizeScalePolicy::Type arg2 ;
31773
31774   arg1 = (Dali::Actor *)jarg1;
31775   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31776   {
31777     try {
31778       (arg1)->SetSizeScalePolicy(arg2);
31779     } catch (std::out_of_range& e) {
31780       {
31781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31782       };
31783     } catch (std::exception& e) {
31784       {
31785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31786       };
31787     } catch (...) {
31788       {
31789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31790       };
31791     }
31792   }
31793 }
31794
31795
31796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31797   int jresult ;
31798   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31799   Dali::SizeScalePolicy::Type result;
31800
31801   arg1 = (Dali::Actor *)jarg1;
31802   {
31803     try {
31804       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31805     } catch (std::out_of_range& e) {
31806       {
31807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (std::exception& e) {
31810       {
31811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31812       };
31813     } catch (...) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31816       };
31817     }
31818   }
31819   jresult = (int)result;
31820   return jresult;
31821 }
31822
31823
31824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31826   Dali::Vector3 *arg2 = 0 ;
31827
31828   arg1 = (Dali::Actor *)jarg1;
31829   arg2 = (Dali::Vector3 *)jarg2;
31830   if (!arg2) {
31831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31832     return ;
31833   }
31834   {
31835     try {
31836       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31837     } catch (std::out_of_range& e) {
31838       {
31839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31840       };
31841     } catch (std::exception& e) {
31842       {
31843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31844       };
31845     } catch (...) {
31846       {
31847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31848       };
31849     }
31850   }
31851 }
31852
31853
31854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31855   void * jresult ;
31856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31857   Dali::Vector3 result;
31858
31859   arg1 = (Dali::Actor *)jarg1;
31860   {
31861     try {
31862       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31863     } catch (std::out_of_range& e) {
31864       {
31865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31866       };
31867     } catch (std::exception& e) {
31868       {
31869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31870       };
31871     } catch (...) {
31872       {
31873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31874       };
31875     }
31876   }
31877   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31878   return jresult;
31879 }
31880
31881
31882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31883   float jresult ;
31884   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31885   float arg2 ;
31886   float result;
31887
31888   arg1 = (Dali::Actor *)jarg1;
31889   arg2 = (float)jarg2;
31890   {
31891     try {
31892       result = (float)(arg1)->GetHeightForWidth(arg2);
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (...) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31904       };
31905     }
31906   }
31907   jresult = result;
31908   return jresult;
31909 }
31910
31911
31912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31913   float jresult ;
31914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31915   float arg2 ;
31916   float result;
31917
31918   arg1 = (Dali::Actor *)jarg1;
31919   arg2 = (float)jarg2;
31920   {
31921     try {
31922       result = (float)(arg1)->GetWidthForHeight(arg2);
31923     } catch (std::out_of_range& e) {
31924       {
31925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31926       };
31927     } catch (std::exception& e) {
31928       {
31929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31930       };
31931     } catch (...) {
31932       {
31933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31934       };
31935     }
31936   }
31937   jresult = result;
31938   return jresult;
31939 }
31940
31941
31942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31943   float jresult ;
31944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31945   Dali::Dimension::Type arg2 ;
31946   float result;
31947
31948   arg1 = (Dali::Actor *)jarg1;
31949   arg2 = (Dali::Dimension::Type)jarg2;
31950   {
31951     try {
31952       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31953     } catch (std::out_of_range& e) {
31954       {
31955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31956       };
31957     } catch (std::exception& e) {
31958       {
31959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31960       };
31961     } catch (...) {
31962       {
31963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31964       };
31965     }
31966   }
31967   jresult = result;
31968   return jresult;
31969 }
31970
31971
31972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31974   Dali::Padding *arg2 = 0 ;
31975
31976   arg1 = (Dali::Actor *)jarg1;
31977   arg2 = (Dali::Padding *)jarg2;
31978   if (!arg2) {
31979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31980     return ;
31981   }
31982   {
31983     try {
31984       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31985     } catch (std::out_of_range& e) {
31986       {
31987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31988       };
31989     } catch (std::exception& e) {
31990       {
31991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31992       };
31993     } catch (...) {
31994       {
31995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31996       };
31997     }
31998   }
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32004   Dali::Padding *arg2 = 0 ;
32005
32006   arg1 = (Dali::Actor *)jarg1;
32007   arg2 = (Dali::Padding *)jarg2;
32008   if (!arg2) {
32009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32010     return ;
32011   }
32012   {
32013     try {
32014       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32015     } catch (std::out_of_range& e) {
32016       {
32017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32018       };
32019     } catch (std::exception& e) {
32020       {
32021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32022       };
32023     } catch (...) {
32024       {
32025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32026       };
32027     }
32028   }
32029 }
32030
32031
32032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32034   Dali::Vector2 *arg2 = 0 ;
32035
32036   arg1 = (Dali::Actor *)jarg1;
32037   arg2 = (Dali::Vector2 *)jarg2;
32038   if (!arg2) {
32039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32040     return ;
32041   }
32042   {
32043     try {
32044       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32045     } catch (std::out_of_range& e) {
32046       {
32047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32048       };
32049     } catch (std::exception& e) {
32050       {
32051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32052       };
32053     } catch (...) {
32054       {
32055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32056       };
32057     }
32058   }
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32063   void * jresult ;
32064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32065   Dali::Vector2 result;
32066
32067   arg1 = (Dali::Actor *)jarg1;
32068   {
32069     try {
32070       result = (arg1)->GetMinimumSize();
32071     } catch (std::out_of_range& e) {
32072       {
32073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32074       };
32075     } catch (std::exception& e) {
32076       {
32077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32078       };
32079     } catch (...) {
32080       {
32081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32082       };
32083     }
32084   }
32085   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32086   return jresult;
32087 }
32088
32089
32090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32092   Dali::Vector2 *arg2 = 0 ;
32093
32094   arg1 = (Dali::Actor *)jarg1;
32095   arg2 = (Dali::Vector2 *)jarg2;
32096   if (!arg2) {
32097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32098     return ;
32099   }
32100   {
32101     try {
32102       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32103     } catch (std::out_of_range& e) {
32104       {
32105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32106       };
32107     } catch (std::exception& e) {
32108       {
32109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32114       };
32115     }
32116   }
32117 }
32118
32119
32120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32121   void * jresult ;
32122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32123   Dali::Vector2 result;
32124
32125   arg1 = (Dali::Actor *)jarg1;
32126   {
32127     try {
32128       result = (arg1)->GetMaximumSize();
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 (...) {
32138       {
32139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32140       };
32141     }
32142   }
32143   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32144   return jresult;
32145 }
32146
32147
32148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32149   int jresult ;
32150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32151   int result;
32152
32153   arg1 = (Dali::Actor *)jarg1;
32154   {
32155     try {
32156       result = (int)(arg1)->GetHierarchyDepth();
32157     } catch (std::out_of_range& e) {
32158       {
32159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32160       };
32161     } catch (std::exception& e) {
32162       {
32163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32168       };
32169     }
32170   }
32171   jresult = result;
32172   return jresult;
32173 }
32174
32175
32176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32177   unsigned int jresult ;
32178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32179   Dali::Renderer *arg2 = 0 ;
32180   unsigned int result;
32181
32182   arg1 = (Dali::Actor *)jarg1;
32183   arg2 = (Dali::Renderer *)jarg2;
32184   if (!arg2) {
32185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32186     return 0;
32187   }
32188   {
32189     try {
32190       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32191     } catch (std::out_of_range& e) {
32192       {
32193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32194       };
32195     } catch (std::exception& e) {
32196       {
32197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32198       };
32199     } catch (...) {
32200       {
32201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32202       };
32203     }
32204   }
32205   jresult = result;
32206   return jresult;
32207 }
32208
32209
32210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32211   unsigned int jresult ;
32212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32213   unsigned int result;
32214
32215   arg1 = (Dali::Actor *)jarg1;
32216   {
32217     try {
32218       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32219     } catch (std::out_of_range& e) {
32220       {
32221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32222       };
32223     } catch (std::exception& e) {
32224       {
32225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32226       };
32227     } catch (...) {
32228       {
32229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32230       };
32231     }
32232   }
32233   jresult = result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32239   void * jresult ;
32240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32241   unsigned int arg2 ;
32242   Dali::Renderer result;
32243
32244   arg1 = (Dali::Actor *)jarg1;
32245   arg2 = (unsigned int)jarg2;
32246   {
32247     try {
32248       result = (arg1)->GetRendererAt(arg2);
32249     } catch (std::out_of_range& e) {
32250       {
32251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32252       };
32253     } catch (std::exception& e) {
32254       {
32255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32256       };
32257     } catch (...) {
32258       {
32259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32260       };
32261     }
32262   }
32263   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32264   return jresult;
32265 }
32266
32267
32268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32270   Dali::Renderer *arg2 = 0 ;
32271
32272   arg1 = (Dali::Actor *)jarg1;
32273   arg2 = (Dali::Renderer *)jarg2;
32274   if (!arg2) {
32275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32276     return ;
32277   }
32278   {
32279     try {
32280       (arg1)->RemoveRenderer(*arg2);
32281     } catch (std::out_of_range& e) {
32282       {
32283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32284       };
32285     } catch (std::exception& e) {
32286       {
32287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32288       };
32289     } catch (...) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32292       };
32293     }
32294   }
32295 }
32296
32297
32298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32300   unsigned int arg2 ;
32301
32302   arg1 = (Dali::Actor *)jarg1;
32303   arg2 = (unsigned int)jarg2;
32304   {
32305     try {
32306       (arg1)->RemoveRenderer(arg2);
32307     } catch (std::out_of_range& e) {
32308       {
32309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32310       };
32311     } catch (std::exception& e) {
32312       {
32313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32314       };
32315     } catch (...) {
32316       {
32317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32318       };
32319     }
32320   }
32321 }
32322
32323
32324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32325   void * jresult ;
32326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32327   Dali::Actor::TouchSignalType *result = 0 ;
32328
32329   arg1 = (Dali::Actor *)jarg1;
32330   {
32331     try {
32332       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
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 (...) {
32342       {
32343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32344       };
32345     }
32346   }
32347   jresult = (void *)result;
32348   return jresult;
32349 }
32350
32351
32352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32353   void * jresult ;
32354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32355   Dali::Actor::TouchDataSignalType *result = 0 ;
32356
32357   arg1 = (Dali::Actor *)jarg1;
32358   {
32359     try {
32360       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32361     } catch (std::out_of_range& e) {
32362       {
32363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32364       };
32365     } catch (std::exception& e) {
32366       {
32367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32368       };
32369     } catch (...) {
32370       {
32371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32372       };
32373     }
32374   }
32375   jresult = (void *)result;
32376   return jresult;
32377 }
32378
32379
32380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32381   void * jresult ;
32382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32383   Dali::Actor::HoverSignalType *result = 0 ;
32384
32385   arg1 = (Dali::Actor *)jarg1;
32386   {
32387     try {
32388       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32389     } catch (std::out_of_range& e) {
32390       {
32391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32392       };
32393     } catch (std::exception& e) {
32394       {
32395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32396       };
32397     } catch (...) {
32398       {
32399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32400       };
32401     }
32402   }
32403   jresult = (void *)result;
32404   return jresult;
32405 }
32406
32407
32408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32409   void * jresult ;
32410   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32411   Dali::Actor::WheelEventSignalType *result = 0 ;
32412
32413   arg1 = (Dali::Actor *)jarg1;
32414   {
32415     try {
32416       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32417     } catch (std::out_of_range& e) {
32418       {
32419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32420       };
32421     } catch (std::exception& e) {
32422       {
32423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32424       };
32425     } catch (...) {
32426       {
32427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32428       };
32429     }
32430   }
32431   jresult = (void *)result;
32432   return jresult;
32433 }
32434
32435
32436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32437   void * jresult ;
32438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32439   Dali::Actor::OnStageSignalType *result = 0 ;
32440
32441   arg1 = (Dali::Actor *)jarg1;
32442   {
32443     try {
32444       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32445     } catch (std::out_of_range& e) {
32446       {
32447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32448       };
32449     } catch (std::exception& e) {
32450       {
32451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (...) {
32454       {
32455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32456       };
32457     }
32458   }
32459   jresult = (void *)result;
32460   return jresult;
32461 }
32462
32463
32464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32465   void * jresult ;
32466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32467   Dali::Actor::OffStageSignalType *result = 0 ;
32468
32469   arg1 = (Dali::Actor *)jarg1;
32470   {
32471     try {
32472       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32480       };
32481     } catch (...) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32484       };
32485     }
32486   }
32487   jresult = (void *)result;
32488   return jresult;
32489 }
32490
32491
32492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32493   void * jresult ;
32494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32495   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32496
32497   arg1 = (Dali::Actor *)jarg1;
32498   {
32499     try {
32500       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32501     } catch (std::out_of_range& e) {
32502       {
32503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32504       };
32505     } catch (std::exception& e) {
32506       {
32507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32508       };
32509     } catch (...) {
32510       {
32511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32512       };
32513     }
32514   }
32515   jresult = (void *)result;
32516   return jresult;
32517 }
32518
32519
32520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32521   Dali::Actor *arg1 = 0 ;
32522
32523   arg1 = (Dali::Actor *)jarg1;
32524   if (!arg1) {
32525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32526     return ;
32527   }
32528   {
32529     try {
32530       Dali::UnparentAndReset(*arg1);
32531     } catch (std::out_of_range& e) {
32532       {
32533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32534       };
32535     } catch (std::exception& e) {
32536       {
32537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32538       };
32539     } catch (...) {
32540       {
32541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32542       };
32543     }
32544   }
32545 }
32546
32547
32548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32549   int jresult ;
32550   int result;
32551
32552   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32553   jresult = (int)result;
32554   return jresult;
32555 }
32556
32557
32558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32559   int jresult ;
32560   int result;
32561
32562   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32563   jresult = (int)result;
32564   return jresult;
32565 }
32566
32567
32568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32569   int jresult ;
32570   int result;
32571
32572   result = (int)Dali::Layer::Property::BEHAVIOR;
32573   jresult = (int)result;
32574   return jresult;
32575 }
32576
32577
32578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32579   void * jresult ;
32580   Dali::Layer::Property *result = 0 ;
32581
32582   {
32583     try {
32584       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32585     } catch (std::out_of_range& e) {
32586       {
32587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32588       };
32589     } catch (std::exception& e) {
32590       {
32591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32592       };
32593     } catch (...) {
32594       {
32595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32596       };
32597     }
32598   }
32599   jresult = (void *)result;
32600   return jresult;
32601 }
32602
32603
32604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32605   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32606
32607   arg1 = (Dali::Layer::Property *)jarg1;
32608   {
32609     try {
32610       delete arg1;
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32618       };
32619     } catch (...) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32622       };
32623     }
32624   }
32625 }
32626
32627
32628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32629   void * jresult ;
32630   Dali::Layer *result = 0 ;
32631
32632   {
32633     try {
32634       result = (Dali::Layer *)new Dali::Layer();
32635     } catch (std::out_of_range& e) {
32636       {
32637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32638       };
32639     } catch (std::exception& e) {
32640       {
32641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32642       };
32643     } catch (...) {
32644       {
32645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32646       };
32647     }
32648   }
32649   jresult = (void *)result;
32650   return jresult;
32651 }
32652
32653
32654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32655   void * jresult ;
32656   Dali::Layer result;
32657
32658   {
32659     try {
32660       result = Dali::Layer::New();
32661     } catch (std::out_of_range& e) {
32662       {
32663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32664       };
32665     } catch (std::exception& e) {
32666       {
32667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32668       };
32669     } catch (...) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32672       };
32673     }
32674   }
32675   jresult = new Dali::Layer((const Dali::Layer &)result);
32676   return jresult;
32677 }
32678
32679
32680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32681   void * jresult ;
32682   Dali::BaseHandle arg1 ;
32683   Dali::BaseHandle *argp1 ;
32684   Dali::Layer result;
32685
32686   argp1 = (Dali::BaseHandle *)jarg1;
32687   if (!argp1) {
32688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32689     return 0;
32690   }
32691   arg1 = *argp1;
32692   {
32693     try {
32694       result = Dali::Layer::DownCast(arg1);
32695     } catch (std::out_of_range& e) {
32696       {
32697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32698       };
32699     } catch (std::exception& e) {
32700       {
32701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32702       };
32703     } catch (...) {
32704       {
32705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32706       };
32707     }
32708   }
32709   jresult = new Dali::Layer((const Dali::Layer &)result);
32710   return jresult;
32711 }
32712
32713
32714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32715   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32716
32717   arg1 = (Dali::Layer *)jarg1;
32718   {
32719     try {
32720       delete arg1;
32721     } catch (std::out_of_range& e) {
32722       {
32723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (std::exception& e) {
32726       {
32727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735 }
32736
32737
32738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32739   void * jresult ;
32740   Dali::Layer *arg1 = 0 ;
32741   Dali::Layer *result = 0 ;
32742
32743   arg1 = (Dali::Layer *)jarg1;
32744   if (!arg1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32746     return 0;
32747   }
32748   {
32749     try {
32750       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32751     } catch (std::out_of_range& e) {
32752       {
32753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32754       };
32755     } catch (std::exception& e) {
32756       {
32757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32758       };
32759     } catch (...) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32762       };
32763     }
32764   }
32765   jresult = (void *)result;
32766   return jresult;
32767 }
32768
32769
32770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32771   void * jresult ;
32772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32773   Dali::Layer *arg2 = 0 ;
32774   Dali::Layer *result = 0 ;
32775
32776   arg1 = (Dali::Layer *)jarg1;
32777   arg2 = (Dali::Layer *)jarg2;
32778   if (!arg2) {
32779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32780     return 0;
32781   }
32782   {
32783     try {
32784       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32785     } catch (std::out_of_range& e) {
32786       {
32787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32788       };
32789     } catch (std::exception& e) {
32790       {
32791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32792       };
32793     } catch (...) {
32794       {
32795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32796       };
32797     }
32798   }
32799   jresult = (void *)result;
32800   return jresult;
32801 }
32802
32803
32804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32805   unsigned int jresult ;
32806   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32807   unsigned int result;
32808
32809   arg1 = (Dali::Layer *)jarg1;
32810   {
32811     try {
32812       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32813     } catch (std::out_of_range& e) {
32814       {
32815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32816       };
32817     } catch (std::exception& e) {
32818       {
32819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (...) {
32822       {
32823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32824       };
32825     }
32826   }
32827   jresult = result;
32828   return jresult;
32829 }
32830
32831
32832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32833   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32834
32835   arg1 = (Dali::Layer *)jarg1;
32836   {
32837     try {
32838       (arg1)->Raise();
32839     } catch (std::out_of_range& e) {
32840       {
32841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32842       };
32843     } catch (std::exception& e) {
32844       {
32845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32846       };
32847     } catch (...) {
32848       {
32849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32850       };
32851     }
32852   }
32853 }
32854
32855
32856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32857   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32858
32859   arg1 = (Dali::Layer *)jarg1;
32860   {
32861     try {
32862       (arg1)->Lower();
32863     } catch (std::out_of_range& e) {
32864       {
32865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32866       };
32867     } catch (std::exception& e) {
32868       {
32869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32870       };
32871     } catch (...) {
32872       {
32873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32874       };
32875     }
32876   }
32877 }
32878
32879
32880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32881   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32882   Dali::Layer arg2 ;
32883   Dali::Layer *argp2 ;
32884
32885   arg1 = (Dali::Layer *)jarg1;
32886   argp2 = (Dali::Layer *)jarg2;
32887   if (!argp2) {
32888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32889     return ;
32890   }
32891   arg2 = *argp2;
32892   {
32893     try {
32894       (arg1)->RaiseAbove(arg2);
32895     } catch (std::out_of_range& e) {
32896       {
32897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32898       };
32899     } catch (std::exception& e) {
32900       {
32901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32902       };
32903     } catch (...) {
32904       {
32905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32906       };
32907     }
32908   }
32909 }
32910
32911
32912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32913   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32914   Dali::Layer arg2 ;
32915   Dali::Layer *argp2 ;
32916
32917   arg1 = (Dali::Layer *)jarg1;
32918   argp2 = (Dali::Layer *)jarg2;
32919   if (!argp2) {
32920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32921     return ;
32922   }
32923   arg2 = *argp2;
32924   {
32925     try {
32926       (arg1)->LowerBelow(arg2);
32927     } catch (std::out_of_range& e) {
32928       {
32929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32930       };
32931     } catch (std::exception& e) {
32932       {
32933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32934       };
32935     } catch (...) {
32936       {
32937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32938       };
32939     }
32940   }
32941 }
32942
32943
32944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32945   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32946
32947   arg1 = (Dali::Layer *)jarg1;
32948   {
32949     try {
32950       (arg1)->RaiseToTop();
32951     } catch (std::out_of_range& e) {
32952       {
32953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32954       };
32955     } catch (std::exception& e) {
32956       {
32957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32958       };
32959     } catch (...) {
32960       {
32961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32962       };
32963     }
32964   }
32965 }
32966
32967
32968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32969   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32970
32971   arg1 = (Dali::Layer *)jarg1;
32972   {
32973     try {
32974       (arg1)->LowerToBottom();
32975     } catch (std::out_of_range& e) {
32976       {
32977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32978       };
32979     } catch (std::exception& e) {
32980       {
32981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32982       };
32983     } catch (...) {
32984       {
32985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32986       };
32987     }
32988   }
32989 }
32990
32991
32992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32993   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32994   Dali::Layer arg2 ;
32995   Dali::Layer *argp2 ;
32996
32997   arg1 = (Dali::Layer *)jarg1;
32998   argp2 = (Dali::Layer *)jarg2;
32999   if (!argp2) {
33000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33001     return ;
33002   }
33003   arg2 = *argp2;
33004   {
33005     try {
33006       (arg1)->MoveAbove(arg2);
33007     } catch (std::out_of_range& e) {
33008       {
33009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33010       };
33011     } catch (std::exception& e) {
33012       {
33013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33014       };
33015     } catch (...) {
33016       {
33017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33018       };
33019     }
33020   }
33021 }
33022
33023
33024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33025   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33026   Dali::Layer arg2 ;
33027   Dali::Layer *argp2 ;
33028
33029   arg1 = (Dali::Layer *)jarg1;
33030   argp2 = (Dali::Layer *)jarg2;
33031   if (!argp2) {
33032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33033     return ;
33034   }
33035   arg2 = *argp2;
33036   {
33037     try {
33038       (arg1)->MoveBelow(arg2);
33039     } catch (std::out_of_range& e) {
33040       {
33041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33042       };
33043     } catch (std::exception& e) {
33044       {
33045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33046       };
33047     } catch (...) {
33048       {
33049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33050       };
33051     }
33052   }
33053 }
33054
33055
33056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33057   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33058   Dali::Layer::Behavior arg2 ;
33059
33060   arg1 = (Dali::Layer *)jarg1;
33061   arg2 = (Dali::Layer::Behavior)jarg2;
33062   {
33063     try {
33064       (arg1)->SetBehavior(arg2);
33065     } catch (std::out_of_range& e) {
33066       {
33067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33068       };
33069     } catch (std::exception& e) {
33070       {
33071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33072       };
33073     } catch (...) {
33074       {
33075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33076       };
33077     }
33078   }
33079 }
33080
33081
33082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33083   int jresult ;
33084   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33085   Dali::Layer::Behavior result;
33086
33087   arg1 = (Dali::Layer *)jarg1;
33088   {
33089     try {
33090       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33091     } catch (std::out_of_range& e) {
33092       {
33093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33094       };
33095     } catch (std::exception& e) {
33096       {
33097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33098       };
33099     } catch (...) {
33100       {
33101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33102       };
33103     }
33104   }
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33111   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33112   bool arg2 ;
33113
33114   arg1 = (Dali::Layer *)jarg1;
33115   arg2 = jarg2 ? true : false;
33116   {
33117     try {
33118       (arg1)->SetClipping(arg2);
33119     } catch (std::out_of_range& e) {
33120       {
33121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33122       };
33123     } catch (std::exception& e) {
33124       {
33125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33126       };
33127     } catch (...) {
33128       {
33129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33130       };
33131     }
33132   }
33133 }
33134
33135
33136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33137   unsigned int jresult ;
33138   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33139   bool result;
33140
33141   arg1 = (Dali::Layer *)jarg1;
33142   {
33143     try {
33144       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33145     } catch (std::out_of_range& e) {
33146       {
33147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33148       };
33149     } catch (std::exception& e) {
33150       {
33151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33152       };
33153     } catch (...) {
33154       {
33155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33156       };
33157     }
33158   }
33159   jresult = result;
33160   return jresult;
33161 }
33162
33163
33164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33165   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33166   int arg2 ;
33167   int arg3 ;
33168   int arg4 ;
33169   int arg5 ;
33170
33171   arg1 = (Dali::Layer *)jarg1;
33172   arg2 = (int)jarg2;
33173   arg3 = (int)jarg3;
33174   arg4 = (int)jarg4;
33175   arg5 = (int)jarg5;
33176   {
33177     try {
33178       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33179     } catch (std::out_of_range& e) {
33180       {
33181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33182       };
33183     } catch (std::exception& e) {
33184       {
33185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33186       };
33187     } catch (...) {
33188       {
33189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33190       };
33191     }
33192   }
33193 }
33194
33195
33196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33197   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33198   Dali::ClippingBox arg2 ;
33199   Dali::ClippingBox *argp2 ;
33200
33201   arg1 = (Dali::Layer *)jarg1;
33202   argp2 = (Dali::ClippingBox *)jarg2;
33203   if (!argp2) {
33204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33205     return ;
33206   }
33207   arg2 = *argp2;
33208   {
33209     try {
33210       (arg1)->SetClippingBox(arg2);
33211     } catch (std::out_of_range& e) {
33212       {
33213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33214       };
33215     } catch (std::exception& e) {
33216       {
33217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33218       };
33219     } catch (...) {
33220       {
33221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33222       };
33223     }
33224   }
33225 }
33226
33227
33228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33229   void * jresult ;
33230   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33231   Dali::ClippingBox result;
33232
33233   arg1 = (Dali::Layer *)jarg1;
33234   {
33235     try {
33236       result = ((Dali::Layer const *)arg1)->GetClippingBox();
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 (...) {
33246       {
33247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33248       };
33249     }
33250   }
33251   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33252   return jresult;
33253 }
33254
33255
33256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33257   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33258   bool arg2 ;
33259
33260   arg1 = (Dali::Layer *)jarg1;
33261   arg2 = jarg2 ? true : false;
33262   {
33263     try {
33264       (arg1)->SetDepthTestDisabled(arg2);
33265     } catch (std::out_of_range& e) {
33266       {
33267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33268       };
33269     } catch (std::exception& e) {
33270       {
33271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33272       };
33273     } catch (...) {
33274       {
33275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33276       };
33277     }
33278   }
33279 }
33280
33281
33282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33283   unsigned int jresult ;
33284   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33285   bool result;
33286
33287   arg1 = (Dali::Layer *)jarg1;
33288   {
33289     try {
33290       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33291     } catch (std::out_of_range& e) {
33292       {
33293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33294       };
33295     } catch (std::exception& e) {
33296       {
33297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33298       };
33299     } catch (...) {
33300       {
33301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33302       };
33303     }
33304   }
33305   jresult = result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33311   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33312   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33313
33314   arg1 = (Dali::Layer *)jarg1;
33315   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33316   {
33317     try {
33318       (arg1)->SetSortFunction(arg2);
33319     } catch (std::out_of_range& e) {
33320       {
33321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33322       };
33323     } catch (std::exception& e) {
33324       {
33325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33326       };
33327     } catch (...) {
33328       {
33329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33330       };
33331     }
33332   }
33333 }
33334
33335
33336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33337   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33338   bool arg2 ;
33339
33340   arg1 = (Dali::Layer *)jarg1;
33341   arg2 = jarg2 ? true : false;
33342   {
33343     try {
33344       (arg1)->SetTouchConsumed(arg2);
33345     } catch (std::out_of_range& e) {
33346       {
33347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33348       };
33349     } catch (std::exception& e) {
33350       {
33351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33352       };
33353     } catch (...) {
33354       {
33355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33356       };
33357     }
33358   }
33359 }
33360
33361
33362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33363   unsigned int jresult ;
33364   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33365   bool result;
33366
33367   arg1 = (Dali::Layer *)jarg1;
33368   {
33369     try {
33370       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33371     } catch (std::out_of_range& e) {
33372       {
33373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33374       };
33375     } catch (std::exception& e) {
33376       {
33377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33378       };
33379     } catch (...) {
33380       {
33381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33382       };
33383     }
33384   }
33385   jresult = result;
33386   return jresult;
33387 }
33388
33389
33390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33391   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33392   bool arg2 ;
33393
33394   arg1 = (Dali::Layer *)jarg1;
33395   arg2 = jarg2 ? true : false;
33396   {
33397     try {
33398       (arg1)->SetHoverConsumed(arg2);
33399     } catch (std::out_of_range& e) {
33400       {
33401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33402       };
33403     } catch (std::exception& e) {
33404       {
33405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33406       };
33407     } catch (...) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33410       };
33411     }
33412   }
33413 }
33414
33415
33416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33417   unsigned int jresult ;
33418   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33419   bool result;
33420
33421   arg1 = (Dali::Layer *)jarg1;
33422   {
33423     try {
33424       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33425     } catch (std::out_of_range& e) {
33426       {
33427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33428       };
33429     } catch (std::exception& e) {
33430       {
33431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33432       };
33433     } catch (...) {
33434       {
33435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33436       };
33437     }
33438   }
33439   jresult = result;
33440   return jresult;
33441 }
33442
33443
33444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33445   void * jresult ;
33446   Dali::Vector4 *result = 0 ;
33447
33448   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33449   jresult = (void *)result;
33450   return jresult;
33451 }
33452
33453
33454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33455   void * jresult ;
33456   Dali::Vector4 *result = 0 ;
33457
33458   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33459   jresult = (void *)result;
33460   return jresult;
33461 }
33462
33463
33464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33465   void * jresult ;
33466   Dali::Stage *result = 0 ;
33467
33468   {
33469     try {
33470       result = (Dali::Stage *)new Dali::Stage();
33471     } catch (std::out_of_range& e) {
33472       {
33473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33474       };
33475     } catch (std::exception& e) {
33476       {
33477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33478       };
33479     } catch (...) {
33480       {
33481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33482       };
33483     }
33484   }
33485   jresult = (void *)result;
33486   return jresult;
33487 }
33488
33489
33490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33491   void * jresult ;
33492   Dali::Stage result;
33493
33494   {
33495     try {
33496       result = Dali::Stage::GetCurrent();
33497     } catch (std::out_of_range& e) {
33498       {
33499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33500       };
33501     } catch (std::exception& e) {
33502       {
33503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33504       };
33505     } catch (...) {
33506       {
33507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33508       };
33509     }
33510   }
33511   jresult = new Dali::Stage((const Dali::Stage &)result);
33512   return jresult;
33513 }
33514
33515
33516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33517   unsigned int jresult ;
33518   bool result;
33519
33520   {
33521     try {
33522       result = (bool)Dali::Stage::IsInstalled();
33523     } catch (std::out_of_range& e) {
33524       {
33525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33526       };
33527     } catch (std::exception& e) {
33528       {
33529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33530       };
33531     } catch (...) {
33532       {
33533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33534       };
33535     }
33536   }
33537   jresult = result;
33538   return jresult;
33539 }
33540
33541
33542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33543   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33544
33545   arg1 = (Dali::Stage *)jarg1;
33546   {
33547     try {
33548       delete arg1;
33549     } catch (std::out_of_range& e) {
33550       {
33551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33552       };
33553     } catch (std::exception& e) {
33554       {
33555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33556       };
33557     } catch (...) {
33558       {
33559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33560       };
33561     }
33562   }
33563 }
33564
33565
33566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33567   void * jresult ;
33568   Dali::Stage *arg1 = 0 ;
33569   Dali::Stage *result = 0 ;
33570
33571   arg1 = (Dali::Stage *)jarg1;
33572   if (!arg1) {
33573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33574     return 0;
33575   }
33576   {
33577     try {
33578       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33579     } catch (std::out_of_range& e) {
33580       {
33581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (std::exception& e) {
33584       {
33585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33586       };
33587     } catch (...) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33590       };
33591     }
33592   }
33593   jresult = (void *)result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33599   void * jresult ;
33600   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33601   Dali::Stage *arg2 = 0 ;
33602   Dali::Stage *result = 0 ;
33603
33604   arg1 = (Dali::Stage *)jarg1;
33605   arg2 = (Dali::Stage *)jarg2;
33606   if (!arg2) {
33607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33608     return 0;
33609   }
33610   {
33611     try {
33612       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33613     } catch (std::out_of_range& e) {
33614       {
33615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (std::exception& e) {
33618       {
33619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33620       };
33621     } catch (...) {
33622       {
33623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33624       };
33625     }
33626   }
33627   jresult = (void *)result;
33628   return jresult;
33629 }
33630
33631
33632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33633   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33634   Dali::Actor *arg2 = 0 ;
33635
33636   arg1 = (Dali::Stage *)jarg1;
33637   arg2 = (Dali::Actor *)jarg2;
33638   if (!arg2) {
33639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33640     return ;
33641   }
33642   {
33643     try {
33644       (arg1)->Add(*arg2);
33645     } catch (std::out_of_range& e) {
33646       {
33647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33648       };
33649     } catch (std::exception& e) {
33650       {
33651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33652       };
33653     } catch (...) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33656       };
33657     }
33658   }
33659 }
33660
33661
33662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33663   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33664   Dali::Actor *arg2 = 0 ;
33665
33666   arg1 = (Dali::Stage *)jarg1;
33667   arg2 = (Dali::Actor *)jarg2;
33668   if (!arg2) {
33669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33670     return ;
33671   }
33672   {
33673     try {
33674       (arg1)->Remove(*arg2);
33675     } catch (std::out_of_range& e) {
33676       {
33677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33678       };
33679     } catch (std::exception& e) {
33680       {
33681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33682       };
33683     } catch (...) {
33684       {
33685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33686       };
33687     }
33688   }
33689 }
33690
33691
33692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33693   void * jresult ;
33694   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33695   Dali::Vector2 result;
33696
33697   arg1 = (Dali::Stage *)jarg1;
33698   {
33699     try {
33700       result = ((Dali::Stage const *)arg1)->GetSize();
33701     } catch (std::out_of_range& e) {
33702       {
33703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33704       };
33705     } catch (std::exception& e) {
33706       {
33707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33708       };
33709     } catch (...) {
33710       {
33711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33712       };
33713     }
33714   }
33715   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33716   return jresult;
33717 }
33718
33719
33720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33721   void * jresult ;
33722   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33723   Dali::RenderTaskList result;
33724
33725   arg1 = (Dali::Stage *)jarg1;
33726   {
33727     try {
33728       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33729     } catch (std::out_of_range& e) {
33730       {
33731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33732       };
33733     } catch (std::exception& e) {
33734       {
33735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33736       };
33737     } catch (...) {
33738       {
33739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33740       };
33741     }
33742   }
33743   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33744   return jresult;
33745 }
33746
33747
33748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33749   unsigned int jresult ;
33750   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33751   unsigned int result;
33752
33753   arg1 = (Dali::Stage *)jarg1;
33754   {
33755     try {
33756       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33757     } catch (std::out_of_range& e) {
33758       {
33759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33760       };
33761     } catch (std::exception& e) {
33762       {
33763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33764       };
33765     } catch (...) {
33766       {
33767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33768       };
33769     }
33770   }
33771   jresult = result;
33772   return jresult;
33773 }
33774
33775
33776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33777   void * jresult ;
33778   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33779   unsigned int arg2 ;
33780   Dali::Layer result;
33781
33782   arg1 = (Dali::Stage *)jarg1;
33783   arg2 = (unsigned int)jarg2;
33784   {
33785     try {
33786       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33787     } catch (std::out_of_range& e) {
33788       {
33789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33790       };
33791     } catch (std::exception& e) {
33792       {
33793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33794       };
33795     } catch (...) {
33796       {
33797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33798       };
33799     }
33800   }
33801   jresult = new Dali::Layer((const Dali::Layer &)result);
33802   return jresult;
33803 }
33804
33805
33806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33807   void * jresult ;
33808   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33809   Dali::Layer result;
33810
33811   arg1 = (Dali::Stage *)jarg1;
33812   {
33813     try {
33814       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (...) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33826       };
33827     }
33828   }
33829   jresult = new Dali::Layer((const Dali::Layer &)result);
33830   return jresult;
33831 }
33832
33833
33834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33835   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33836   Dali::Vector4 arg2 ;
33837   Dali::Vector4 *argp2 ;
33838
33839   arg1 = (Dali::Stage *)jarg1;
33840   argp2 = (Dali::Vector4 *)jarg2;
33841   if (!argp2) {
33842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33843     return ;
33844   }
33845   arg2 = *argp2;
33846   {
33847     try {
33848       (arg1)->SetBackgroundColor(arg2);
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33860       };
33861     }
33862   }
33863 }
33864
33865
33866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33867   void * jresult ;
33868   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33869   Dali::Vector4 result;
33870
33871   arg1 = (Dali::Stage *)jarg1;
33872   {
33873     try {
33874       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33875     } catch (std::out_of_range& e) {
33876       {
33877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33878       };
33879     } catch (std::exception& e) {
33880       {
33881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33882       };
33883     } catch (...) {
33884       {
33885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33886       };
33887     }
33888   }
33889   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33890   return jresult;
33891 }
33892
33893
33894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33895   void * jresult ;
33896   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33897   Dali::Vector2 result;
33898
33899   arg1 = (Dali::Stage *)jarg1;
33900   {
33901     try {
33902       result = ((Dali::Stage const *)arg1)->GetDpi();
33903     } catch (std::out_of_range& e) {
33904       {
33905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33906       };
33907     } catch (std::exception& e) {
33908       {
33909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33910       };
33911     } catch (...) {
33912       {
33913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33914       };
33915     }
33916   }
33917   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33918   return jresult;
33919 }
33920
33921
33922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33923   void * jresult ;
33924   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33925   Dali::ObjectRegistry result;
33926
33927   arg1 = (Dali::Stage *)jarg1;
33928   {
33929     try {
33930       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33931     } catch (std::out_of_range& e) {
33932       {
33933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33934       };
33935     } catch (std::exception& e) {
33936       {
33937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33938       };
33939     } catch (...) {
33940       {
33941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33942       };
33943     }
33944   }
33945   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33946   return jresult;
33947 }
33948
33949
33950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33951   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33952   float arg2 ;
33953
33954   arg1 = (Dali::Stage *)jarg1;
33955   arg2 = (float)jarg2;
33956   {
33957     try {
33958       (arg1)->KeepRendering(arg2);
33959     } catch (std::out_of_range& e) {
33960       {
33961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33962       };
33963     } catch (std::exception& e) {
33964       {
33965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33970       };
33971     }
33972   }
33973 }
33974
33975
33976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33977   void * jresult ;
33978   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33979   Dali::Stage::KeyEventSignalType *result = 0 ;
33980
33981   arg1 = (Dali::Stage *)jarg1;
33982   {
33983     try {
33984       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (...) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33996       };
33997     }
33998   }
33999   jresult = (void *)result;
34000   return jresult;
34001 }
34002
34003
34004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34005   void * jresult ;
34006   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34007   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34008
34009   arg1 = (Dali::Stage *)jarg1;
34010   {
34011     try {
34012       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34013     } catch (std::out_of_range& e) {
34014       {
34015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34016       };
34017     } catch (std::exception& e) {
34018       {
34019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34020       };
34021     } catch (...) {
34022       {
34023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34024       };
34025     }
34026   }
34027   jresult = (void *)result;
34028   return jresult;
34029 }
34030
34031
34032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34033   void * jresult ;
34034   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34035   Dali::Stage::TouchSignalType *result = 0 ;
34036
34037   arg1 = (Dali::Stage *)jarg1;
34038   {
34039     try {
34040       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34041     } catch (std::out_of_range& e) {
34042       {
34043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34044       };
34045     } catch (std::exception& e) {
34046       {
34047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34048       };
34049     } catch (...) {
34050       {
34051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34052       };
34053     }
34054   }
34055   jresult = (void *)result;
34056   return jresult;
34057 }
34058
34059
34060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34061   void * jresult ;
34062   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34063   Dali::Stage::WheelEventSignalType *result = 0 ;
34064
34065   arg1 = (Dali::Stage *)jarg1;
34066   {
34067     try {
34068       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34069     } catch (std::out_of_range& e) {
34070       {
34071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34072       };
34073     } catch (std::exception& e) {
34074       {
34075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34076       };
34077     } catch (...) {
34078       {
34079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34080       };
34081     }
34082   }
34083   jresult = (void *)result;
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34089   void * jresult ;
34090   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34091   Dali::Stage::ContextStatusSignal *result = 0 ;
34092
34093   arg1 = (Dali::Stage *)jarg1;
34094   {
34095     try {
34096       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (...) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34108       };
34109     }
34110   }
34111   jresult = (void *)result;
34112   return jresult;
34113 }
34114
34115
34116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34117   void * jresult ;
34118   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34119   Dali::Stage::ContextStatusSignal *result = 0 ;
34120
34121   arg1 = (Dali::Stage *)jarg1;
34122   {
34123     try {
34124       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34125     } catch (std::out_of_range& e) {
34126       {
34127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34128       };
34129     } catch (std::exception& e) {
34130       {
34131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34132       };
34133     } catch (...) {
34134       {
34135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34136       };
34137     }
34138   }
34139   jresult = (void *)result;
34140   return jresult;
34141 }
34142
34143
34144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34145   void * jresult ;
34146   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34147   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34148
34149   arg1 = (Dali::Stage *)jarg1;
34150   {
34151     try {
34152       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34153     } catch (std::out_of_range& e) {
34154       {
34155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34156       };
34157     } catch (std::exception& e) {
34158       {
34159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34160       };
34161     } catch (...) {
34162       {
34163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34164       };
34165     }
34166   }
34167   jresult = (void *)result;
34168   return jresult;
34169 }
34170
34171
34172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34173   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34174
34175   arg1 = (Dali::RelayoutContainer *)jarg1;
34176   {
34177     try {
34178       delete arg1;
34179     } catch (std::out_of_range& e) {
34180       {
34181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34182       };
34183     } catch (std::exception& e) {
34184       {
34185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34186       };
34187     } catch (...) {
34188       {
34189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34190       };
34191     }
34192   }
34193 }
34194
34195
34196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34197   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34198   Dali::Actor *arg2 = 0 ;
34199   Dali::Vector2 *arg3 = 0 ;
34200
34201   arg1 = (Dali::RelayoutContainer *)jarg1;
34202   arg2 = (Dali::Actor *)jarg2;
34203   if (!arg2) {
34204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34205     return ;
34206   }
34207   arg3 = (Dali::Vector2 *)jarg3;
34208   if (!arg3) {
34209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34210     return ;
34211   }
34212   {
34213     try {
34214       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34215     } catch (std::out_of_range& e) {
34216       {
34217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34218       };
34219     } catch (std::exception& e) {
34220       {
34221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34222       };
34223     } catch (...) {
34224       {
34225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34226       };
34227     }
34228   }
34229 }
34230
34231
34232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34233   void * jresult ;
34234   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34235   Dali::CustomActor result;
34236
34237   arg1 = (Dali::CustomActorImpl *)jarg1;
34238   {
34239     try {
34240       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34241     } catch (std::out_of_range& e) {
34242       {
34243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34244       };
34245     } catch (std::exception& e) {
34246       {
34247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34252       };
34253     }
34254   }
34255   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34256   return jresult;
34257 }
34258
34259
34260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34261   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34262   int arg2 ;
34263
34264   arg1 = (Dali::CustomActorImpl *)jarg1;
34265   arg2 = (int)jarg2;
34266   {
34267     try {
34268       (arg1)->OnStageConnection(arg2);
34269     } catch (std::out_of_range& e) {
34270       {
34271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34272       };
34273     } catch (std::exception& e) {
34274       {
34275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34280       };
34281     }
34282   }
34283 }
34284
34285
34286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34287   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34288
34289   arg1 = (Dali::CustomActorImpl *)jarg1;
34290   {
34291     try {
34292       (arg1)->OnStageDisconnection();
34293     } catch (std::out_of_range& e) {
34294       {
34295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34296       };
34297     } catch (std::exception& e) {
34298       {
34299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34300       };
34301     } catch (...) {
34302       {
34303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34304       };
34305     }
34306   }
34307 }
34308
34309
34310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34311   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34312   Dali::Actor *arg2 = 0 ;
34313
34314   arg1 = (Dali::CustomActorImpl *)jarg1;
34315   arg2 = (Dali::Actor *)jarg2;
34316   if (!arg2) {
34317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34318     return ;
34319   }
34320   {
34321     try {
34322       (arg1)->OnChildAdd(*arg2);
34323     } catch (std::out_of_range& e) {
34324       {
34325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34326       };
34327     } catch (std::exception& e) {
34328       {
34329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34330       };
34331     } catch (...) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34334       };
34335     }
34336   }
34337 }
34338
34339
34340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34341   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34342   Dali::Actor *arg2 = 0 ;
34343
34344   arg1 = (Dali::CustomActorImpl *)jarg1;
34345   arg2 = (Dali::Actor *)jarg2;
34346   if (!arg2) {
34347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34348     return ;
34349   }
34350   {
34351     try {
34352       (arg1)->OnChildRemove(*arg2);
34353     } catch (std::out_of_range& e) {
34354       {
34355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34356       };
34357     } catch (std::exception& e) {
34358       {
34359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34360       };
34361     } catch (...) {
34362       {
34363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34364       };
34365     }
34366   }
34367 }
34368
34369
34370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34371   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34372   Dali::Property::Index arg2 ;
34373   Dali::Property::Value arg3 ;
34374   Dali::Property::Value *argp3 ;
34375
34376   arg1 = (Dali::CustomActorImpl *)jarg1;
34377   arg2 = (Dali::Property::Index)jarg2;
34378   argp3 = (Dali::Property::Value *)jarg3;
34379   if (!argp3) {
34380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34381     return ;
34382   }
34383   arg3 = *argp3;
34384   {
34385     try {
34386       (arg1)->OnPropertySet(arg2,arg3);
34387     } catch (std::out_of_range& e) {
34388       {
34389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34390       };
34391     } catch (std::exception& e) {
34392       {
34393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34394       };
34395     } catch (...) {
34396       {
34397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34398       };
34399     }
34400   }
34401 }
34402
34403
34404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34405   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34406   Dali::Vector3 *arg2 = 0 ;
34407
34408   arg1 = (Dali::CustomActorImpl *)jarg1;
34409   arg2 = (Dali::Vector3 *)jarg2;
34410   if (!arg2) {
34411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34412     return ;
34413   }
34414   {
34415     try {
34416       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34417     } catch (std::out_of_range& e) {
34418       {
34419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34420       };
34421     } catch (std::exception& e) {
34422       {
34423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34424       };
34425     } catch (...) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34428       };
34429     }
34430   }
34431 }
34432
34433
34434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34435   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34436   Dali::Animation *arg2 = 0 ;
34437   Dali::Vector3 *arg3 = 0 ;
34438
34439   arg1 = (Dali::CustomActorImpl *)jarg1;
34440   arg2 = (Dali::Animation *)jarg2;
34441   if (!arg2) {
34442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34443     return ;
34444   }
34445   arg3 = (Dali::Vector3 *)jarg3;
34446   if (!arg3) {
34447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34448     return ;
34449   }
34450   {
34451     try {
34452       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34453     } catch (std::out_of_range& e) {
34454       {
34455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34456       };
34457     } catch (std::exception& e) {
34458       {
34459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34460       };
34461     } catch (...) {
34462       {
34463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34464       };
34465     }
34466   }
34467 }
34468
34469
34470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34471   unsigned int jresult ;
34472   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34473   Dali::TouchEvent *arg2 = 0 ;
34474   bool result;
34475
34476   arg1 = (Dali::CustomActorImpl *)jarg1;
34477   arg2 = (Dali::TouchEvent *)jarg2;
34478   if (!arg2) {
34479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34480     return 0;
34481   }
34482   {
34483     try {
34484       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34485     } catch (std::out_of_range& e) {
34486       {
34487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34488       };
34489     } catch (std::exception& e) {
34490       {
34491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34492       };
34493     } catch (...) {
34494       {
34495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34496       };
34497     }
34498   }
34499   jresult = result;
34500   return jresult;
34501 }
34502
34503
34504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34505   unsigned int jresult ;
34506   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34507   Dali::HoverEvent *arg2 = 0 ;
34508   bool result;
34509
34510   arg1 = (Dali::CustomActorImpl *)jarg1;
34511   arg2 = (Dali::HoverEvent *)jarg2;
34512   if (!arg2) {
34513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34514     return 0;
34515   }
34516   {
34517     try {
34518       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34519     } catch (std::out_of_range& e) {
34520       {
34521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34522       };
34523     } catch (std::exception& e) {
34524       {
34525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34526       };
34527     } catch (...) {
34528       {
34529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34530       };
34531     }
34532   }
34533   jresult = result;
34534   return jresult;
34535 }
34536
34537
34538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34539   unsigned int jresult ;
34540   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34541   Dali::KeyEvent *arg2 = 0 ;
34542   bool result;
34543
34544   arg1 = (Dali::CustomActorImpl *)jarg1;
34545   arg2 = (Dali::KeyEvent *)jarg2;
34546   if (!arg2) {
34547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34548     return 0;
34549   }
34550   {
34551     try {
34552       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34553     } catch (std::out_of_range& e) {
34554       {
34555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34556       };
34557     } catch (std::exception& e) {
34558       {
34559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34560       };
34561     } catch (...) {
34562       {
34563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34564       };
34565     }
34566   }
34567   jresult = result;
34568   return jresult;
34569 }
34570
34571
34572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34573   unsigned int jresult ;
34574   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34575   Dali::WheelEvent *arg2 = 0 ;
34576   bool result;
34577
34578   arg1 = (Dali::CustomActorImpl *)jarg1;
34579   arg2 = (Dali::WheelEvent *)jarg2;
34580   if (!arg2) {
34581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34582     return 0;
34583   }
34584   {
34585     try {
34586       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34587     } catch (std::out_of_range& e) {
34588       {
34589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34590       };
34591     } catch (std::exception& e) {
34592       {
34593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34594       };
34595     } catch (...) {
34596       {
34597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34598       };
34599     }
34600   }
34601   jresult = result;
34602   return jresult;
34603 }
34604
34605
34606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34608   Dali::Vector2 *arg2 = 0 ;
34609   Dali::RelayoutContainer *arg3 = 0 ;
34610
34611   arg1 = (Dali::CustomActorImpl *)jarg1;
34612   arg2 = (Dali::Vector2 *)jarg2;
34613   if (!arg2) {
34614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34615     return ;
34616   }
34617   arg3 = (Dali::RelayoutContainer *)jarg3;
34618   if (!arg3) {
34619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34620     return ;
34621   }
34622   {
34623     try {
34624       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34625     } catch (std::out_of_range& e) {
34626       {
34627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34628       };
34629     } catch (std::exception& e) {
34630       {
34631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34632       };
34633     } catch (...) {
34634       {
34635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34636       };
34637     }
34638   }
34639 }
34640
34641
34642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34644   Dali::ResizePolicy::Type arg2 ;
34645   Dali::Dimension::Type arg3 ;
34646
34647   arg1 = (Dali::CustomActorImpl *)jarg1;
34648   arg2 = (Dali::ResizePolicy::Type)jarg2;
34649   arg3 = (Dali::Dimension::Type)jarg3;
34650   {
34651     try {
34652       (arg1)->OnSetResizePolicy(arg2,arg3);
34653     } catch (std::out_of_range& e) {
34654       {
34655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34656       };
34657     } catch (std::exception& e) {
34658       {
34659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34660       };
34661     } catch (...) {
34662       {
34663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34664       };
34665     }
34666   }
34667 }
34668
34669
34670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34671   void * jresult ;
34672   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34673   Dali::Vector3 result;
34674
34675   arg1 = (Dali::CustomActorImpl *)jarg1;
34676   {
34677     try {
34678       result = (arg1)->GetNaturalSize();
34679     } catch (std::out_of_range& e) {
34680       {
34681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (std::exception& e) {
34684       {
34685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34686       };
34687     } catch (...) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34690       };
34691     }
34692   }
34693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34694   return jresult;
34695 }
34696
34697
34698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34699   float jresult ;
34700   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34701   Dali::Actor *arg2 = 0 ;
34702   Dali::Dimension::Type arg3 ;
34703   float result;
34704
34705   arg1 = (Dali::CustomActorImpl *)jarg1;
34706   arg2 = (Dali::Actor *)jarg2;
34707   if (!arg2) {
34708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34709     return 0;
34710   }
34711   arg3 = (Dali::Dimension::Type)jarg3;
34712   {
34713     try {
34714       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34715     } catch (std::out_of_range& e) {
34716       {
34717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34718       };
34719     } catch (std::exception& e) {
34720       {
34721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34722       };
34723     } catch (...) {
34724       {
34725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34726       };
34727     }
34728   }
34729   jresult = result;
34730   return jresult;
34731 }
34732
34733
34734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34735   float jresult ;
34736   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34737   float arg2 ;
34738   float result;
34739
34740   arg1 = (Dali::CustomActorImpl *)jarg1;
34741   arg2 = (float)jarg2;
34742   {
34743     try {
34744       result = (float)(arg1)->GetHeightForWidth(arg2);
34745     } catch (std::out_of_range& e) {
34746       {
34747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34748       };
34749     } catch (std::exception& e) {
34750       {
34751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34752       };
34753     } catch (...) {
34754       {
34755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34756       };
34757     }
34758   }
34759   jresult = result;
34760   return jresult;
34761 }
34762
34763
34764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34765   float jresult ;
34766   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34767   float arg2 ;
34768   float result;
34769
34770   arg1 = (Dali::CustomActorImpl *)jarg1;
34771   arg2 = (float)jarg2;
34772   {
34773     try {
34774       result = (float)(arg1)->GetWidthForHeight(arg2);
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34782       };
34783     } catch (...) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34786       };
34787     }
34788   }
34789   jresult = result;
34790   return jresult;
34791 }
34792
34793
34794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34795   unsigned int jresult ;
34796   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34797   Dali::Dimension::Type arg2 ;
34798   bool result;
34799
34800   arg1 = (Dali::CustomActorImpl *)jarg1;
34801   arg2 = (Dali::Dimension::Type)jarg2;
34802   {
34803     try {
34804       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34805     } catch (std::out_of_range& e) {
34806       {
34807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34808       };
34809     } catch (std::exception& e) {
34810       {
34811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34812       };
34813     } catch (...) {
34814       {
34815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34816       };
34817     }
34818   }
34819   jresult = result;
34820   return jresult;
34821 }
34822
34823
34824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34825   unsigned int jresult ;
34826   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34827   bool result;
34828
34829   arg1 = (Dali::CustomActorImpl *)jarg1;
34830   {
34831     try {
34832       result = (bool)(arg1)->RelayoutDependentOnChildren();
34833     } catch (std::out_of_range& e) {
34834       {
34835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34836       };
34837     } catch (std::exception& e) {
34838       {
34839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34840       };
34841     } catch (...) {
34842       {
34843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34844       };
34845     }
34846   }
34847   jresult = result;
34848   return jresult;
34849 }
34850
34851
34852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34853   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34854   Dali::Dimension::Type arg2 ;
34855
34856   arg1 = (Dali::CustomActorImpl *)jarg1;
34857   arg2 = (Dali::Dimension::Type)jarg2;
34858   {
34859     try {
34860       (arg1)->OnCalculateRelayoutSize(arg2);
34861     } catch (std::out_of_range& e) {
34862       {
34863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34864       };
34865     } catch (std::exception& e) {
34866       {
34867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34868       };
34869     } catch (...) {
34870       {
34871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34872       };
34873     }
34874   }
34875 }
34876
34877
34878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34879   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34880   float arg2 ;
34881   Dali::Dimension::Type arg3 ;
34882
34883   arg1 = (Dali::CustomActorImpl *)jarg1;
34884   arg2 = (float)jarg2;
34885   arg3 = (Dali::Dimension::Type)jarg3;
34886   {
34887     try {
34888       (arg1)->OnLayoutNegotiated(arg2,arg3);
34889     } catch (std::out_of_range& e) {
34890       {
34891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34892       };
34893     } catch (std::exception& e) {
34894       {
34895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34896       };
34897     } catch (...) {
34898       {
34899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34900       };
34901     }
34902   }
34903 }
34904
34905
34906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34907   unsigned int jresult ;
34908   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34909   bool result;
34910
34911   arg1 = (Dali::CustomActorImpl *)jarg1;
34912   {
34913     try {
34914       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34915     } catch (std::out_of_range& e) {
34916       {
34917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34918       };
34919     } catch (std::exception& e) {
34920       {
34921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34922       };
34923     } catch (...) {
34924       {
34925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34926       };
34927     }
34928   }
34929   jresult = result;
34930   return jresult;
34931 }
34932
34933
34934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34935   unsigned int jresult ;
34936   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34937   bool result;
34938
34939   arg1 = (Dali::CustomActorImpl *)jarg1;
34940   {
34941     try {
34942       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34943     } catch (std::out_of_range& e) {
34944       {
34945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34946       };
34947     } catch (std::exception& e) {
34948       {
34949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34950       };
34951     } catch (...) {
34952       {
34953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34954       };
34955     }
34956   }
34957   jresult = result;
34958   return jresult;
34959 }
34960
34961
34962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34963   unsigned int jresult ;
34964   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34965   bool result;
34966
34967   arg1 = (Dali::CustomActorImpl *)jarg1;
34968   {
34969     try {
34970       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34971     } catch (std::out_of_range& e) {
34972       {
34973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34974       };
34975     } catch (std::exception& e) {
34976       {
34977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34978       };
34979     } catch (...) {
34980       {
34981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34982       };
34983     }
34984   }
34985   jresult = result;
34986   return jresult;
34987 }
34988
34989
34990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34991   unsigned int jresult ;
34992   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34993   bool result;
34994
34995   arg1 = (Dali::CustomActorImpl *)jarg1;
34996   {
34997     try {
34998       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34999     } catch (std::out_of_range& e) {
35000       {
35001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35002       };
35003     } catch (std::exception& e) {
35004       {
35005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35006       };
35007     } catch (...) {
35008       {
35009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35010       };
35011     }
35012   }
35013   jresult = result;
35014   return jresult;
35015 }
35016
35017
35018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35019   void * jresult ;
35020   Dali::CustomActor *result = 0 ;
35021
35022   {
35023     try {
35024       result = (Dali::CustomActor *)new Dali::CustomActor();
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 (...) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35036       };
35037     }
35038   }
35039   jresult = (void *)result;
35040   return jresult;
35041 }
35042
35043
35044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35045   void * jresult ;
35046   Dali::BaseHandle arg1 ;
35047   Dali::BaseHandle *argp1 ;
35048   Dali::CustomActor result;
35049
35050   argp1 = (Dali::BaseHandle *)jarg1;
35051   if (!argp1) {
35052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35053     return 0;
35054   }
35055   arg1 = *argp1;
35056   {
35057     try {
35058       result = Dali::CustomActor::DownCast(arg1);
35059     } catch (std::out_of_range& e) {
35060       {
35061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35062       };
35063     } catch (std::exception& e) {
35064       {
35065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35066       };
35067     } catch (...) {
35068       {
35069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35070       };
35071     }
35072   }
35073   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35074   return jresult;
35075 }
35076
35077
35078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35079   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35080
35081   arg1 = (Dali::CustomActor *)jarg1;
35082   {
35083     try {
35084       delete arg1;
35085     } catch (std::out_of_range& e) {
35086       {
35087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35088       };
35089     } catch (std::exception& e) {
35090       {
35091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35092       };
35093     } catch (...) {
35094       {
35095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35096       };
35097     }
35098   }
35099 }
35100
35101
35102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35103   void * jresult ;
35104   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35105   Dali::CustomActorImpl *result = 0 ;
35106
35107   arg1 = (Dali::CustomActor *)jarg1;
35108   {
35109     try {
35110       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35111     } catch (std::out_of_range& e) {
35112       {
35113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35114       };
35115     } catch (std::exception& e) {
35116       {
35117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35118       };
35119     } catch (...) {
35120       {
35121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35122       };
35123     }
35124   }
35125   jresult = (void *)result;
35126   return jresult;
35127 }
35128
35129
35130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35131   void * jresult ;
35132   Dali::CustomActorImpl *arg1 = 0 ;
35133   Dali::CustomActor *result = 0 ;
35134
35135   arg1 = (Dali::CustomActorImpl *)jarg1;
35136   if (!arg1) {
35137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35138     return 0;
35139   }
35140   {
35141     try {
35142       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35143     } catch (std::out_of_range& e) {
35144       {
35145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35146       };
35147     } catch (std::exception& e) {
35148       {
35149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35150       };
35151     } catch (...) {
35152       {
35153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35154       };
35155     }
35156   }
35157   jresult = (void *)result;
35158   return jresult;
35159 }
35160
35161
35162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35163   void * jresult ;
35164   Dali::CustomActor *arg1 = 0 ;
35165   Dali::CustomActor *result = 0 ;
35166
35167   arg1 = (Dali::CustomActor *)jarg1;
35168   if (!arg1) {
35169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35170     return 0;
35171   }
35172   {
35173     try {
35174       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35175     } catch (std::out_of_range& e) {
35176       {
35177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35178       };
35179     } catch (std::exception& e) {
35180       {
35181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35182       };
35183     } catch (...) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35186       };
35187     }
35188   }
35189   jresult = (void *)result;
35190   return jresult;
35191 }
35192
35193
35194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35195   void * jresult ;
35196   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35197   Dali::CustomActor *arg2 = 0 ;
35198   Dali::CustomActor *result = 0 ;
35199
35200   arg1 = (Dali::CustomActor *)jarg1;
35201   arg2 = (Dali::CustomActor *)jarg2;
35202   if (!arg2) {
35203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35204     return 0;
35205   }
35206   {
35207     try {
35208       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35209     } catch (std::out_of_range& e) {
35210       {
35211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35212       };
35213     } catch (std::exception& e) {
35214       {
35215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35216       };
35217     } catch (...) {
35218       {
35219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35220       };
35221     }
35222   }
35223   jresult = (void *)result;
35224   return jresult;
35225 }
35226
35227
35228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35229   int jresult ;
35230   int result;
35231
35232   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35233   jresult = (int)result;
35234   return jresult;
35235 }
35236
35237
35238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35239   int jresult ;
35240   int result;
35241
35242   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35243   jresult = (int)result;
35244   return jresult;
35245 }
35246
35247
35248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35249   int jresult ;
35250   int result;
35251
35252   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35253   jresult = (int)result;
35254   return jresult;
35255 }
35256
35257
35258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35259   int jresult ;
35260   int result;
35261
35262   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35263   jresult = (int)result;
35264   return jresult;
35265 }
35266
35267
35268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35269   int jresult ;
35270   int result;
35271
35272   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35273   jresult = (int)result;
35274   return jresult;
35275 }
35276
35277
35278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35279   int jresult ;
35280   int result;
35281
35282   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35283   jresult = (int)result;
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35289   int jresult ;
35290   int result;
35291
35292   result = (int)Dali::PanGestureDetector::Property::PANNING;
35293   jresult = (int)result;
35294   return jresult;
35295 }
35296
35297
35298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35299   void * jresult ;
35300   Dali::PanGestureDetector::Property *result = 0 ;
35301
35302   {
35303     try {
35304       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35305     } catch (std::out_of_range& e) {
35306       {
35307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35308       };
35309     } catch (std::exception& e) {
35310       {
35311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35312       };
35313     } catch (...) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35316       };
35317     }
35318   }
35319   jresult = (void *)result;
35320   return jresult;
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35325   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35326
35327   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35328   {
35329     try {
35330       delete arg1;
35331     } catch (std::out_of_range& e) {
35332       {
35333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35334       };
35335     } catch (std::exception& e) {
35336       {
35337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (...) {
35340       {
35341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35342       };
35343     }
35344   }
35345 }
35346
35347
35348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35349   void * jresult ;
35350   Dali::Radian *result = 0 ;
35351
35352   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35353   jresult = (void *)result;
35354   return jresult;
35355 }
35356
35357
35358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35359   void * jresult ;
35360   Dali::Radian *result = 0 ;
35361
35362   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35363   jresult = (void *)result;
35364   return jresult;
35365 }
35366
35367
35368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35369   void * jresult ;
35370   Dali::Radian *result = 0 ;
35371
35372   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35373   jresult = (void *)result;
35374   return jresult;
35375 }
35376
35377
35378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35379   void * jresult ;
35380   Dali::Radian *result = 0 ;
35381
35382   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35383   jresult = (void *)result;
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35389   void * jresult ;
35390   Dali::Radian *result = 0 ;
35391
35392   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35393   jresult = (void *)result;
35394   return jresult;
35395 }
35396
35397
35398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35399   void * jresult ;
35400   Dali::Radian *result = 0 ;
35401
35402   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35403   jresult = (void *)result;
35404   return jresult;
35405 }
35406
35407
35408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35409   void * jresult ;
35410   Dali::Radian *result = 0 ;
35411
35412   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35413   jresult = (void *)result;
35414   return jresult;
35415 }
35416
35417
35418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35419   void * jresult ;
35420   Dali::PanGestureDetector *result = 0 ;
35421
35422   {
35423     try {
35424       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35425     } catch (std::out_of_range& e) {
35426       {
35427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35428       };
35429     } catch (std::exception& e) {
35430       {
35431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35432       };
35433     } catch (...) {
35434       {
35435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35436       };
35437     }
35438   }
35439   jresult = (void *)result;
35440   return jresult;
35441 }
35442
35443
35444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35445   void * jresult ;
35446   Dali::PanGestureDetector result;
35447
35448   {
35449     try {
35450       result = Dali::PanGestureDetector::New();
35451     } catch (std::out_of_range& e) {
35452       {
35453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35454       };
35455     } catch (std::exception& e) {
35456       {
35457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35458       };
35459     } catch (...) {
35460       {
35461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35462       };
35463     }
35464   }
35465   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35466   return jresult;
35467 }
35468
35469
35470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35471   void * jresult ;
35472   Dali::BaseHandle arg1 ;
35473   Dali::BaseHandle *argp1 ;
35474   Dali::PanGestureDetector result;
35475
35476   argp1 = (Dali::BaseHandle *)jarg1;
35477   if (!argp1) {
35478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35479     return 0;
35480   }
35481   arg1 = *argp1;
35482   {
35483     try {
35484       result = Dali::PanGestureDetector::DownCast(arg1);
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 (...) {
35494       {
35495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35496       };
35497     }
35498   }
35499   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35500   return jresult;
35501 }
35502
35503
35504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35505   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35506
35507   arg1 = (Dali::PanGestureDetector *)jarg1;
35508   {
35509     try {
35510       delete arg1;
35511     } catch (std::out_of_range& e) {
35512       {
35513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35514       };
35515     } catch (std::exception& e) {
35516       {
35517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35518       };
35519     } catch (...) {
35520       {
35521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35522       };
35523     }
35524   }
35525 }
35526
35527
35528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35529   void * jresult ;
35530   Dali::PanGestureDetector *arg1 = 0 ;
35531   Dali::PanGestureDetector *result = 0 ;
35532
35533   arg1 = (Dali::PanGestureDetector *)jarg1;
35534   if (!arg1) {
35535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35536     return 0;
35537   }
35538   {
35539     try {
35540       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35541     } catch (std::out_of_range& e) {
35542       {
35543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35544       };
35545     } catch (std::exception& e) {
35546       {
35547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35548       };
35549     } catch (...) {
35550       {
35551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35552       };
35553     }
35554   }
35555   jresult = (void *)result;
35556   return jresult;
35557 }
35558
35559
35560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35561   void * jresult ;
35562   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35563   Dali::PanGestureDetector *arg2 = 0 ;
35564   Dali::PanGestureDetector *result = 0 ;
35565
35566   arg1 = (Dali::PanGestureDetector *)jarg1;
35567   arg2 = (Dali::PanGestureDetector *)jarg2;
35568   if (!arg2) {
35569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35570     return 0;
35571   }
35572   {
35573     try {
35574       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35575     } catch (std::out_of_range& e) {
35576       {
35577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35578       };
35579     } catch (std::exception& e) {
35580       {
35581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35582       };
35583     } catch (...) {
35584       {
35585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35586       };
35587     }
35588   }
35589   jresult = (void *)result;
35590   return jresult;
35591 }
35592
35593
35594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35595   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35596   unsigned int arg2 ;
35597
35598   arg1 = (Dali::PanGestureDetector *)jarg1;
35599   arg2 = (unsigned int)jarg2;
35600   {
35601     try {
35602       (arg1)->SetMinimumTouchesRequired(arg2);
35603     } catch (std::out_of_range& e) {
35604       {
35605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35606       };
35607     } catch (std::exception& e) {
35608       {
35609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35610       };
35611     } catch (...) {
35612       {
35613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35614       };
35615     }
35616   }
35617 }
35618
35619
35620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35621   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35622   unsigned int arg2 ;
35623
35624   arg1 = (Dali::PanGestureDetector *)jarg1;
35625   arg2 = (unsigned int)jarg2;
35626   {
35627     try {
35628       (arg1)->SetMaximumTouchesRequired(arg2);
35629     } catch (std::out_of_range& e) {
35630       {
35631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (std::exception& e) {
35634       {
35635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35640       };
35641     }
35642   }
35643 }
35644
35645
35646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35647   unsigned int jresult ;
35648   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35649   unsigned int result;
35650
35651   arg1 = (Dali::PanGestureDetector *)jarg1;
35652   {
35653     try {
35654       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35655     } catch (std::out_of_range& e) {
35656       {
35657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35658       };
35659     } catch (std::exception& e) {
35660       {
35661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35662       };
35663     } catch (...) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35666       };
35667     }
35668   }
35669   jresult = result;
35670   return jresult;
35671 }
35672
35673
35674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35675   unsigned int jresult ;
35676   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35677   unsigned int result;
35678
35679   arg1 = (Dali::PanGestureDetector *)jarg1;
35680   {
35681     try {
35682       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35683     } catch (std::out_of_range& e) {
35684       {
35685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (std::exception& e) {
35688       {
35689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35690       };
35691     } catch (...) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35694       };
35695     }
35696   }
35697   jresult = result;
35698   return jresult;
35699 }
35700
35701
35702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35703   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35704   Dali::Radian arg2 ;
35705   Dali::Radian arg3 ;
35706   Dali::Radian *argp2 ;
35707   Dali::Radian *argp3 ;
35708
35709   arg1 = (Dali::PanGestureDetector *)jarg1;
35710   argp2 = (Dali::Radian *)jarg2;
35711   if (!argp2) {
35712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35713     return ;
35714   }
35715   arg2 = *argp2;
35716   argp3 = (Dali::Radian *)jarg3;
35717   if (!argp3) {
35718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35719     return ;
35720   }
35721   arg3 = *argp3;
35722   {
35723     try {
35724       (arg1)->AddAngle(arg2,arg3);
35725     } catch (std::out_of_range& e) {
35726       {
35727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35728       };
35729     } catch (std::exception& e) {
35730       {
35731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (...) {
35734       {
35735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35736       };
35737     }
35738   }
35739 }
35740
35741
35742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35743   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35744   Dali::Radian arg2 ;
35745   Dali::Radian *argp2 ;
35746
35747   arg1 = (Dali::PanGestureDetector *)jarg1;
35748   argp2 = (Dali::Radian *)jarg2;
35749   if (!argp2) {
35750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35751     return ;
35752   }
35753   arg2 = *argp2;
35754   {
35755     try {
35756       (arg1)->AddAngle(arg2);
35757     } catch (std::out_of_range& e) {
35758       {
35759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35760       };
35761     } catch (std::exception& e) {
35762       {
35763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (...) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35768       };
35769     }
35770   }
35771 }
35772
35773
35774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35775   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35776   Dali::Radian arg2 ;
35777   Dali::Radian arg3 ;
35778   Dali::Radian *argp2 ;
35779   Dali::Radian *argp3 ;
35780
35781   arg1 = (Dali::PanGestureDetector *)jarg1;
35782   argp2 = (Dali::Radian *)jarg2;
35783   if (!argp2) {
35784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35785     return ;
35786   }
35787   arg2 = *argp2;
35788   argp3 = (Dali::Radian *)jarg3;
35789   if (!argp3) {
35790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35791     return ;
35792   }
35793   arg3 = *argp3;
35794   {
35795     try {
35796       (arg1)->AddDirection(arg2,arg3);
35797     } catch (std::out_of_range& e) {
35798       {
35799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (std::exception& e) {
35802       {
35803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35804       };
35805     } catch (...) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35808       };
35809     }
35810   }
35811 }
35812
35813
35814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35815   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35816   Dali::Radian arg2 ;
35817   Dali::Radian *argp2 ;
35818
35819   arg1 = (Dali::PanGestureDetector *)jarg1;
35820   argp2 = (Dali::Radian *)jarg2;
35821   if (!argp2) {
35822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35823     return ;
35824   }
35825   arg2 = *argp2;
35826   {
35827     try {
35828       (arg1)->AddDirection(arg2);
35829     } catch (std::out_of_range& e) {
35830       {
35831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35832       };
35833     } catch (std::exception& e) {
35834       {
35835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35836       };
35837     } catch (...) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35840       };
35841     }
35842   }
35843 }
35844
35845
35846 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35847   unsigned long jresult ;
35848   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35849   size_t result;
35850
35851   arg1 = (Dali::PanGestureDetector *)jarg1;
35852   {
35853     try {
35854       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35855     } catch (std::out_of_range& e) {
35856       {
35857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35858       };
35859     } catch (std::exception& e) {
35860       {
35861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35862       };
35863     } catch (...) {
35864       {
35865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35866       };
35867     }
35868   }
35869   jresult = (unsigned long)result;
35870   return jresult;
35871 }
35872
35873
35874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35875   void * jresult ;
35876   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35877   size_t arg2 ;
35878   Dali::PanGestureDetector::AngleThresholdPair result;
35879
35880   arg1 = (Dali::PanGestureDetector *)jarg1;
35881   arg2 = (size_t)jarg2;
35882   {
35883     try {
35884       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (...) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35896       };
35897     }
35898   }
35899   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35900   return jresult;
35901 }
35902
35903
35904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35905   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35906
35907   arg1 = (Dali::PanGestureDetector *)jarg1;
35908   {
35909     try {
35910       (arg1)->ClearAngles();
35911     } catch (std::out_of_range& e) {
35912       {
35913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35914       };
35915     } catch (std::exception& e) {
35916       {
35917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35918       };
35919     } catch (...) {
35920       {
35921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35922       };
35923     }
35924   }
35925 }
35926
35927
35928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35929   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35930   Dali::Radian arg2 ;
35931   Dali::Radian *argp2 ;
35932
35933   arg1 = (Dali::PanGestureDetector *)jarg1;
35934   argp2 = (Dali::Radian *)jarg2;
35935   if (!argp2) {
35936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35937     return ;
35938   }
35939   arg2 = *argp2;
35940   {
35941     try {
35942       (arg1)->RemoveAngle(arg2);
35943     } catch (std::out_of_range& e) {
35944       {
35945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35946       };
35947     } catch (std::exception& e) {
35948       {
35949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35950       };
35951     } catch (...) {
35952       {
35953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35954       };
35955     }
35956   }
35957 }
35958
35959
35960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35961   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35962   Dali::Radian arg2 ;
35963   Dali::Radian *argp2 ;
35964
35965   arg1 = (Dali::PanGestureDetector *)jarg1;
35966   argp2 = (Dali::Radian *)jarg2;
35967   if (!argp2) {
35968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35969     return ;
35970   }
35971   arg2 = *argp2;
35972   {
35973     try {
35974       (arg1)->RemoveDirection(arg2);
35975     } catch (std::out_of_range& e) {
35976       {
35977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35978       };
35979     } catch (std::exception& e) {
35980       {
35981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35982       };
35983     } catch (...) {
35984       {
35985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35986       };
35987     }
35988   }
35989 }
35990
35991
35992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35993   void * jresult ;
35994   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35995   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35996
35997   arg1 = (Dali::PanGestureDetector *)jarg1;
35998   {
35999     try {
36000       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36001     } catch (std::out_of_range& e) {
36002       {
36003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36004       };
36005     } catch (std::exception& e) {
36006       {
36007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36008       };
36009     } catch (...) {
36010       {
36011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36012       };
36013     }
36014   }
36015   jresult = (void *)result;
36016   return jresult;
36017 }
36018
36019
36020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36021   Dali::PanGesture *arg1 = 0 ;
36022
36023   arg1 = (Dali::PanGesture *)jarg1;
36024   if (!arg1) {
36025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36026     return ;
36027   }
36028   {
36029     try {
36030       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36031     } catch (std::out_of_range& e) {
36032       {
36033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36034       };
36035     } catch (std::exception& e) {
36036       {
36037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36038       };
36039     } catch (...) {
36040       {
36041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36042       };
36043     }
36044   }
36045 }
36046
36047
36048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36049   void * jresult ;
36050   Dali::PanGesture *result = 0 ;
36051
36052   {
36053     try {
36054       result = (Dali::PanGesture *)new Dali::PanGesture();
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (...) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36066       };
36067     }
36068   }
36069   jresult = (void *)result;
36070   return jresult;
36071 }
36072
36073
36074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36075   void * jresult ;
36076   Dali::Gesture::State arg1 ;
36077   Dali::PanGesture *result = 0 ;
36078
36079   arg1 = (Dali::Gesture::State)jarg1;
36080   {
36081     try {
36082       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36083     } catch (std::out_of_range& e) {
36084       {
36085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36086       };
36087     } catch (std::exception& e) {
36088       {
36089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36090       };
36091     } catch (...) {
36092       {
36093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36094       };
36095     }
36096   }
36097   jresult = (void *)result;
36098   return jresult;
36099 }
36100
36101
36102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36103   void * jresult ;
36104   Dali::PanGesture *arg1 = 0 ;
36105   Dali::PanGesture *result = 0 ;
36106
36107   arg1 = (Dali::PanGesture *)jarg1;
36108   if (!arg1) {
36109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36110     return 0;
36111   }
36112   {
36113     try {
36114       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36115     } catch (std::out_of_range& e) {
36116       {
36117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36118       };
36119     } catch (std::exception& e) {
36120       {
36121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (...) {
36124       {
36125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36126       };
36127     }
36128   }
36129   jresult = (void *)result;
36130   return jresult;
36131 }
36132
36133
36134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36135   void * jresult ;
36136   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36137   Dali::PanGesture *arg2 = 0 ;
36138   Dali::PanGesture *result = 0 ;
36139
36140   arg1 = (Dali::PanGesture *)jarg1;
36141   arg2 = (Dali::PanGesture *)jarg2;
36142   if (!arg2) {
36143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36144     return 0;
36145   }
36146   {
36147     try {
36148       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36149     } catch (std::out_of_range& e) {
36150       {
36151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (std::exception& e) {
36154       {
36155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163   jresult = (void *)result;
36164   return jresult;
36165 }
36166
36167
36168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36169   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36170
36171   arg1 = (Dali::PanGesture *)jarg1;
36172   {
36173     try {
36174       delete arg1;
36175     } catch (std::out_of_range& e) {
36176       {
36177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36178       };
36179     } catch (std::exception& e) {
36180       {
36181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36182       };
36183     } catch (...) {
36184       {
36185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36186       };
36187     }
36188   }
36189 }
36190
36191
36192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36193   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36194   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36195
36196   arg1 = (Dali::PanGesture *)jarg1;
36197   arg2 = (Dali::Vector2 *)jarg2;
36198   if (arg1) (arg1)->velocity = *arg2;
36199 }
36200
36201
36202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36203   void * jresult ;
36204   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36205   Dali::Vector2 *result = 0 ;
36206
36207   arg1 = (Dali::PanGesture *)jarg1;
36208   result = (Dali::Vector2 *)& ((arg1)->velocity);
36209   jresult = (void *)result;
36210   return jresult;
36211 }
36212
36213
36214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36215   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36216   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36217
36218   arg1 = (Dali::PanGesture *)jarg1;
36219   arg2 = (Dali::Vector2 *)jarg2;
36220   if (arg1) (arg1)->displacement = *arg2;
36221 }
36222
36223
36224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36225   void * jresult ;
36226   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36227   Dali::Vector2 *result = 0 ;
36228
36229   arg1 = (Dali::PanGesture *)jarg1;
36230   result = (Dali::Vector2 *)& ((arg1)->displacement);
36231   jresult = (void *)result;
36232   return jresult;
36233 }
36234
36235
36236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36237   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36238   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36239
36240   arg1 = (Dali::PanGesture *)jarg1;
36241   arg2 = (Dali::Vector2 *)jarg2;
36242   if (arg1) (arg1)->position = *arg2;
36243 }
36244
36245
36246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36247   void * jresult ;
36248   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36249   Dali::Vector2 *result = 0 ;
36250
36251   arg1 = (Dali::PanGesture *)jarg1;
36252   result = (Dali::Vector2 *)& ((arg1)->position);
36253   jresult = (void *)result;
36254   return jresult;
36255 }
36256
36257
36258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36259   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36260   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36261
36262   arg1 = (Dali::PanGesture *)jarg1;
36263   arg2 = (Dali::Vector2 *)jarg2;
36264   if (arg1) (arg1)->screenVelocity = *arg2;
36265 }
36266
36267
36268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36269   void * jresult ;
36270   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36271   Dali::Vector2 *result = 0 ;
36272
36273   arg1 = (Dali::PanGesture *)jarg1;
36274   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36275   jresult = (void *)result;
36276   return jresult;
36277 }
36278
36279
36280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36281   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36282   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36283
36284   arg1 = (Dali::PanGesture *)jarg1;
36285   arg2 = (Dali::Vector2 *)jarg2;
36286   if (arg1) (arg1)->screenDisplacement = *arg2;
36287 }
36288
36289
36290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36291   void * jresult ;
36292   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36293   Dali::Vector2 *result = 0 ;
36294
36295   arg1 = (Dali::PanGesture *)jarg1;
36296   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36297   jresult = (void *)result;
36298   return jresult;
36299 }
36300
36301
36302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36303   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36304   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36305
36306   arg1 = (Dali::PanGesture *)jarg1;
36307   arg2 = (Dali::Vector2 *)jarg2;
36308   if (arg1) (arg1)->screenPosition = *arg2;
36309 }
36310
36311
36312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36313   void * jresult ;
36314   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36315   Dali::Vector2 *result = 0 ;
36316
36317   arg1 = (Dali::PanGesture *)jarg1;
36318   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36319   jresult = (void *)result;
36320   return jresult;
36321 }
36322
36323
36324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36325   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36326   unsigned int arg2 ;
36327
36328   arg1 = (Dali::PanGesture *)jarg1;
36329   arg2 = (unsigned int)jarg2;
36330   if (arg1) (arg1)->numberOfTouches = arg2;
36331 }
36332
36333
36334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36335   unsigned int jresult ;
36336   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36337   unsigned int result;
36338
36339   arg1 = (Dali::PanGesture *)jarg1;
36340   result = (unsigned int) ((arg1)->numberOfTouches);
36341   jresult = result;
36342   return jresult;
36343 }
36344
36345
36346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36347   float jresult ;
36348   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36349   float result;
36350
36351   arg1 = (Dali::PanGesture *)jarg1;
36352   {
36353     try {
36354       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36362       };
36363     } catch (...) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36366       };
36367     }
36368   }
36369   jresult = result;
36370   return jresult;
36371 }
36372
36373
36374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36375   float jresult ;
36376   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36377   float result;
36378
36379   arg1 = (Dali::PanGesture *)jarg1;
36380   {
36381     try {
36382       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36383     } catch (std::out_of_range& e) {
36384       {
36385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36386       };
36387     } catch (std::exception& e) {
36388       {
36389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36390       };
36391     } catch (...) {
36392       {
36393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36394       };
36395     }
36396   }
36397   jresult = result;
36398   return jresult;
36399 }
36400
36401
36402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36403   float jresult ;
36404   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36405   float result;
36406
36407   arg1 = (Dali::PanGesture *)jarg1;
36408   {
36409     try {
36410       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36411     } catch (std::out_of_range& e) {
36412       {
36413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36414       };
36415     } catch (std::exception& e) {
36416       {
36417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36418       };
36419     } catch (...) {
36420       {
36421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36422       };
36423     }
36424   }
36425   jresult = result;
36426   return jresult;
36427 }
36428
36429
36430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36431   float jresult ;
36432   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36433   float result;
36434
36435   arg1 = (Dali::PanGesture *)jarg1;
36436   {
36437     try {
36438       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36439     } catch (std::out_of_range& e) {
36440       {
36441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36442       };
36443     } catch (std::exception& e) {
36444       {
36445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36446       };
36447     } catch (...) {
36448       {
36449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36450       };
36451     }
36452   }
36453   jresult = result;
36454   return jresult;
36455 }
36456
36457
36458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36459   void * jresult ;
36460   Dali::PinchGestureDetector *result = 0 ;
36461
36462   {
36463     try {
36464       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36465     } catch (std::out_of_range& e) {
36466       {
36467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36468       };
36469     } catch (std::exception& e) {
36470       {
36471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36476       };
36477     }
36478   }
36479   jresult = (void *)result;
36480   return jresult;
36481 }
36482
36483
36484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36485   void * jresult ;
36486   Dali::PinchGestureDetector result;
36487
36488   {
36489     try {
36490       result = Dali::PinchGestureDetector::New();
36491     } catch (std::out_of_range& e) {
36492       {
36493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36494       };
36495     } catch (std::exception& e) {
36496       {
36497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36498       };
36499     } catch (...) {
36500       {
36501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36502       };
36503     }
36504   }
36505   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36506   return jresult;
36507 }
36508
36509
36510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36511   void * jresult ;
36512   Dali::BaseHandle arg1 ;
36513   Dali::BaseHandle *argp1 ;
36514   Dali::PinchGestureDetector result;
36515
36516   argp1 = (Dali::BaseHandle *)jarg1;
36517   if (!argp1) {
36518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36519     return 0;
36520   }
36521   arg1 = *argp1;
36522   {
36523     try {
36524       result = Dali::PinchGestureDetector::DownCast(arg1);
36525     } catch (std::out_of_range& e) {
36526       {
36527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36528       };
36529     } catch (std::exception& e) {
36530       {
36531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36532       };
36533     } catch (...) {
36534       {
36535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36536       };
36537     }
36538   }
36539   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36545   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36546
36547   arg1 = (Dali::PinchGestureDetector *)jarg1;
36548   {
36549     try {
36550       delete arg1;
36551     } catch (std::out_of_range& e) {
36552       {
36553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36554       };
36555     } catch (std::exception& e) {
36556       {
36557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36558       };
36559     } catch (...) {
36560       {
36561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36562       };
36563     }
36564   }
36565 }
36566
36567
36568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36569   void * jresult ;
36570   Dali::PinchGestureDetector *arg1 = 0 ;
36571   Dali::PinchGestureDetector *result = 0 ;
36572
36573   arg1 = (Dali::PinchGestureDetector *)jarg1;
36574   if (!arg1) {
36575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36576     return 0;
36577   }
36578   {
36579     try {
36580       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36581     } catch (std::out_of_range& e) {
36582       {
36583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36584       };
36585     } catch (std::exception& e) {
36586       {
36587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36588       };
36589     } catch (...) {
36590       {
36591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36592       };
36593     }
36594   }
36595   jresult = (void *)result;
36596   return jresult;
36597 }
36598
36599
36600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36601   void * jresult ;
36602   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36603   Dali::PinchGestureDetector *arg2 = 0 ;
36604   Dali::PinchGestureDetector *result = 0 ;
36605
36606   arg1 = (Dali::PinchGestureDetector *)jarg1;
36607   arg2 = (Dali::PinchGestureDetector *)jarg2;
36608   if (!arg2) {
36609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36610     return 0;
36611   }
36612   {
36613     try {
36614       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36615     } catch (std::out_of_range& e) {
36616       {
36617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36618       };
36619     } catch (std::exception& e) {
36620       {
36621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36622       };
36623     } catch (...) {
36624       {
36625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36626       };
36627     }
36628   }
36629   jresult = (void *)result;
36630   return jresult;
36631 }
36632
36633
36634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36635   void * jresult ;
36636   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36637   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36638
36639   arg1 = (Dali::PinchGestureDetector *)jarg1;
36640   {
36641     try {
36642       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36643     } catch (std::out_of_range& e) {
36644       {
36645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36646       };
36647     } catch (std::exception& e) {
36648       {
36649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36650       };
36651     } catch (...) {
36652       {
36653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36654       };
36655     }
36656   }
36657   jresult = (void *)result;
36658   return jresult;
36659 }
36660
36661
36662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36663   void * jresult ;
36664   Dali::Gesture::State arg1 ;
36665   Dali::PinchGesture *result = 0 ;
36666
36667   arg1 = (Dali::Gesture::State)jarg1;
36668   {
36669     try {
36670       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36671     } catch (std::out_of_range& e) {
36672       {
36673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36674       };
36675     } catch (std::exception& e) {
36676       {
36677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36678       };
36679     } catch (...) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36682       };
36683     }
36684   }
36685   jresult = (void *)result;
36686   return jresult;
36687 }
36688
36689
36690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36691   void * jresult ;
36692   Dali::PinchGesture *arg1 = 0 ;
36693   Dali::PinchGesture *result = 0 ;
36694
36695   arg1 = (Dali::PinchGesture *)jarg1;
36696   if (!arg1) {
36697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36698     return 0;
36699   }
36700   {
36701     try {
36702       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36703     } catch (std::out_of_range& e) {
36704       {
36705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36706       };
36707     } catch (std::exception& e) {
36708       {
36709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36710       };
36711     } catch (...) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36714       };
36715     }
36716   }
36717   jresult = (void *)result;
36718   return jresult;
36719 }
36720
36721
36722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36723   void * jresult ;
36724   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36725   Dali::PinchGesture *arg2 = 0 ;
36726   Dali::PinchGesture *result = 0 ;
36727
36728   arg1 = (Dali::PinchGesture *)jarg1;
36729   arg2 = (Dali::PinchGesture *)jarg2;
36730   if (!arg2) {
36731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36732     return 0;
36733   }
36734   {
36735     try {
36736       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36737     } catch (std::out_of_range& e) {
36738       {
36739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36740       };
36741     } catch (std::exception& e) {
36742       {
36743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36744       };
36745     } catch (...) {
36746       {
36747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36748       };
36749     }
36750   }
36751   jresult = (void *)result;
36752   return jresult;
36753 }
36754
36755
36756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36757   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36758
36759   arg1 = (Dali::PinchGesture *)jarg1;
36760   {
36761     try {
36762       delete arg1;
36763     } catch (std::out_of_range& e) {
36764       {
36765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36766       };
36767     } catch (std::exception& e) {
36768       {
36769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36770       };
36771     } catch (...) {
36772       {
36773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36774       };
36775     }
36776   }
36777 }
36778
36779
36780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36781   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36782   float arg2 ;
36783
36784   arg1 = (Dali::PinchGesture *)jarg1;
36785   arg2 = (float)jarg2;
36786   if (arg1) (arg1)->scale = arg2;
36787 }
36788
36789
36790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36791   float jresult ;
36792   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36793   float result;
36794
36795   arg1 = (Dali::PinchGesture *)jarg1;
36796   result = (float) ((arg1)->scale);
36797   jresult = result;
36798   return jresult;
36799 }
36800
36801
36802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36803   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36804   float arg2 ;
36805
36806   arg1 = (Dali::PinchGesture *)jarg1;
36807   arg2 = (float)jarg2;
36808   if (arg1) (arg1)->speed = arg2;
36809 }
36810
36811
36812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36813   float jresult ;
36814   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36815   float result;
36816
36817   arg1 = (Dali::PinchGesture *)jarg1;
36818   result = (float) ((arg1)->speed);
36819   jresult = result;
36820   return jresult;
36821 }
36822
36823
36824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36825   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36826   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36827
36828   arg1 = (Dali::PinchGesture *)jarg1;
36829   arg2 = (Dali::Vector2 *)jarg2;
36830   if (arg1) (arg1)->screenCenterPoint = *arg2;
36831 }
36832
36833
36834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36835   void * jresult ;
36836   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36837   Dali::Vector2 *result = 0 ;
36838
36839   arg1 = (Dali::PinchGesture *)jarg1;
36840   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36841   jresult = (void *)result;
36842   return jresult;
36843 }
36844
36845
36846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36847   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36848   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36849
36850   arg1 = (Dali::PinchGesture *)jarg1;
36851   arg2 = (Dali::Vector2 *)jarg2;
36852   if (arg1) (arg1)->localCenterPoint = *arg2;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36857   void * jresult ;
36858   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36859   Dali::Vector2 *result = 0 ;
36860
36861   arg1 = (Dali::PinchGesture *)jarg1;
36862   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36863   jresult = (void *)result;
36864   return jresult;
36865 }
36866
36867
36868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36869   void * jresult ;
36870   Dali::TapGestureDetector *result = 0 ;
36871
36872   {
36873     try {
36874       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36875     } catch (std::out_of_range& e) {
36876       {
36877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36878       };
36879     } catch (std::exception& e) {
36880       {
36881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36882       };
36883     } catch (...) {
36884       {
36885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36886       };
36887     }
36888   }
36889   jresult = (void *)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36895   void * jresult ;
36896   Dali::TapGestureDetector result;
36897
36898   {
36899     try {
36900       result = Dali::TapGestureDetector::New();
36901     } catch (std::out_of_range& e) {
36902       {
36903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (std::exception& e) {
36906       {
36907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (...) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36912       };
36913     }
36914   }
36915   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36916   return jresult;
36917 }
36918
36919
36920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36921   void * jresult ;
36922   unsigned int arg1 ;
36923   Dali::TapGestureDetector result;
36924
36925   arg1 = (unsigned int)jarg1;
36926   {
36927     try {
36928       result = Dali::TapGestureDetector::New(arg1);
36929     } catch (std::out_of_range& e) {
36930       {
36931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36932       };
36933     } catch (std::exception& e) {
36934       {
36935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36936       };
36937     } catch (...) {
36938       {
36939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36940       };
36941     }
36942   }
36943   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36944   return jresult;
36945 }
36946
36947
36948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36949   void * jresult ;
36950   Dali::BaseHandle arg1 ;
36951   Dali::BaseHandle *argp1 ;
36952   Dali::TapGestureDetector result;
36953
36954   argp1 = (Dali::BaseHandle *)jarg1;
36955   if (!argp1) {
36956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36957     return 0;
36958   }
36959   arg1 = *argp1;
36960   {
36961     try {
36962       result = Dali::TapGestureDetector::DownCast(arg1);
36963     } catch (std::out_of_range& e) {
36964       {
36965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36966       };
36967     } catch (std::exception& e) {
36968       {
36969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36970       };
36971     } catch (...) {
36972       {
36973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36974       };
36975     }
36976   }
36977   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36978   return jresult;
36979 }
36980
36981
36982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36983   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36984
36985   arg1 = (Dali::TapGestureDetector *)jarg1;
36986   {
36987     try {
36988       delete arg1;
36989     } catch (std::out_of_range& e) {
36990       {
36991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36992       };
36993     } catch (std::exception& e) {
36994       {
36995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36996       };
36997     } catch (...) {
36998       {
36999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37000       };
37001     }
37002   }
37003 }
37004
37005
37006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37007   void * jresult ;
37008   Dali::TapGestureDetector *arg1 = 0 ;
37009   Dali::TapGestureDetector *result = 0 ;
37010
37011   arg1 = (Dali::TapGestureDetector *)jarg1;
37012   if (!arg1) {
37013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37014     return 0;
37015   }
37016   {
37017     try {
37018       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37019     } catch (std::out_of_range& e) {
37020       {
37021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37022       };
37023     } catch (std::exception& e) {
37024       {
37025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37026       };
37027     } catch (...) {
37028       {
37029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37030       };
37031     }
37032   }
37033   jresult = (void *)result;
37034   return jresult;
37035 }
37036
37037
37038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37039   void * jresult ;
37040   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37041   Dali::TapGestureDetector *arg2 = 0 ;
37042   Dali::TapGestureDetector *result = 0 ;
37043
37044   arg1 = (Dali::TapGestureDetector *)jarg1;
37045   arg2 = (Dali::TapGestureDetector *)jarg2;
37046   if (!arg2) {
37047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37048     return 0;
37049   }
37050   {
37051     try {
37052       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
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 (...) {
37062       {
37063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37064       };
37065     }
37066   }
37067   jresult = (void *)result;
37068   return jresult;
37069 }
37070
37071
37072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37073   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37074   unsigned int arg2 ;
37075
37076   arg1 = (Dali::TapGestureDetector *)jarg1;
37077   arg2 = (unsigned int)jarg2;
37078   {
37079     try {
37080       (arg1)->SetMinimumTapsRequired(arg2);
37081     } catch (std::out_of_range& e) {
37082       {
37083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37084       };
37085     } catch (std::exception& e) {
37086       {
37087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37088       };
37089     } catch (...) {
37090       {
37091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37092       };
37093     }
37094   }
37095 }
37096
37097
37098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37099   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37100   unsigned int arg2 ;
37101
37102   arg1 = (Dali::TapGestureDetector *)jarg1;
37103   arg2 = (unsigned int)jarg2;
37104   {
37105     try {
37106       (arg1)->SetMaximumTapsRequired(arg2);
37107     } catch (std::out_of_range& e) {
37108       {
37109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37110       };
37111     } catch (std::exception& e) {
37112       {
37113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37114       };
37115     } catch (...) {
37116       {
37117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37118       };
37119     }
37120   }
37121 }
37122
37123
37124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37125   unsigned int jresult ;
37126   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37127   unsigned int result;
37128
37129   arg1 = (Dali::TapGestureDetector *)jarg1;
37130   {
37131     try {
37132       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37133     } catch (std::out_of_range& e) {
37134       {
37135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37136       };
37137     } catch (std::exception& e) {
37138       {
37139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37140       };
37141     } catch (...) {
37142       {
37143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37144       };
37145     }
37146   }
37147   jresult = result;
37148   return jresult;
37149 }
37150
37151
37152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37153   unsigned int jresult ;
37154   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37155   unsigned int result;
37156
37157   arg1 = (Dali::TapGestureDetector *)jarg1;
37158   {
37159     try {
37160       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37161     } catch (std::out_of_range& e) {
37162       {
37163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37164       };
37165     } catch (std::exception& e) {
37166       {
37167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37168       };
37169     } catch (...) {
37170       {
37171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37172       };
37173     }
37174   }
37175   jresult = result;
37176   return jresult;
37177 }
37178
37179
37180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37181   void * jresult ;
37182   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37183   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37184
37185   arg1 = (Dali::TapGestureDetector *)jarg1;
37186   {
37187     try {
37188       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37189     } catch (std::out_of_range& e) {
37190       {
37191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37192       };
37193     } catch (std::exception& e) {
37194       {
37195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37196       };
37197     } catch (...) {
37198       {
37199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37200       };
37201     }
37202   }
37203   jresult = (void *)result;
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37209   void * jresult ;
37210   Dali::TapGesture *result = 0 ;
37211
37212   {
37213     try {
37214       result = (Dali::TapGesture *)new Dali::TapGesture();
37215     } catch (std::out_of_range& e) {
37216       {
37217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37218       };
37219     } catch (std::exception& e) {
37220       {
37221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37222       };
37223     } catch (...) {
37224       {
37225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37226       };
37227     }
37228   }
37229   jresult = (void *)result;
37230   return jresult;
37231 }
37232
37233
37234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37235   void * jresult ;
37236   Dali::TapGesture *arg1 = 0 ;
37237   Dali::TapGesture *result = 0 ;
37238
37239   arg1 = (Dali::TapGesture *)jarg1;
37240   if (!arg1) {
37241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37242     return 0;
37243   }
37244   {
37245     try {
37246       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37247     } catch (std::out_of_range& e) {
37248       {
37249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37250       };
37251     } catch (std::exception& e) {
37252       {
37253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37254       };
37255     } catch (...) {
37256       {
37257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37258       };
37259     }
37260   }
37261   jresult = (void *)result;
37262   return jresult;
37263 }
37264
37265
37266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37267   void * jresult ;
37268   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37269   Dali::TapGesture *arg2 = 0 ;
37270   Dali::TapGesture *result = 0 ;
37271
37272   arg1 = (Dali::TapGesture *)jarg1;
37273   arg2 = (Dali::TapGesture *)jarg2;
37274   if (!arg2) {
37275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37276     return 0;
37277   }
37278   {
37279     try {
37280       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37281     } catch (std::out_of_range& e) {
37282       {
37283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37284       };
37285     } catch (std::exception& e) {
37286       {
37287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37288       };
37289     } catch (...) {
37290       {
37291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37292       };
37293     }
37294   }
37295   jresult = (void *)result;
37296   return jresult;
37297 }
37298
37299
37300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37301   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37302
37303   arg1 = (Dali::TapGesture *)jarg1;
37304   {
37305     try {
37306       delete arg1;
37307     } catch (std::out_of_range& e) {
37308       {
37309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37310       };
37311     } catch (std::exception& e) {
37312       {
37313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37314       };
37315     } catch (...) {
37316       {
37317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37318       };
37319     }
37320   }
37321 }
37322
37323
37324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37325   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37326   unsigned int arg2 ;
37327
37328   arg1 = (Dali::TapGesture *)jarg1;
37329   arg2 = (unsigned int)jarg2;
37330   if (arg1) (arg1)->numberOfTaps = arg2;
37331 }
37332
37333
37334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37335   unsigned int jresult ;
37336   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37337   unsigned int result;
37338
37339   arg1 = (Dali::TapGesture *)jarg1;
37340   result = (unsigned int) ((arg1)->numberOfTaps);
37341   jresult = result;
37342   return jresult;
37343 }
37344
37345
37346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37347   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37348   unsigned int arg2 ;
37349
37350   arg1 = (Dali::TapGesture *)jarg1;
37351   arg2 = (unsigned int)jarg2;
37352   if (arg1) (arg1)->numberOfTouches = arg2;
37353 }
37354
37355
37356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37357   unsigned int jresult ;
37358   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37359   unsigned int result;
37360
37361   arg1 = (Dali::TapGesture *)jarg1;
37362   result = (unsigned int) ((arg1)->numberOfTouches);
37363   jresult = result;
37364   return jresult;
37365 }
37366
37367
37368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37369   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37370   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37371
37372   arg1 = (Dali::TapGesture *)jarg1;
37373   arg2 = (Dali::Vector2 *)jarg2;
37374   if (arg1) (arg1)->screenPoint = *arg2;
37375 }
37376
37377
37378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37379   void * jresult ;
37380   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37381   Dali::Vector2 *result = 0 ;
37382
37383   arg1 = (Dali::TapGesture *)jarg1;
37384   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37385   jresult = (void *)result;
37386   return jresult;
37387 }
37388
37389
37390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37391   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37392   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37393
37394   arg1 = (Dali::TapGesture *)jarg1;
37395   arg2 = (Dali::Vector2 *)jarg2;
37396   if (arg1) (arg1)->localPoint = *arg2;
37397 }
37398
37399
37400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37401   void * jresult ;
37402   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37403   Dali::Vector2 *result = 0 ;
37404
37405   arg1 = (Dali::TapGesture *)jarg1;
37406   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37407   jresult = (void *)result;
37408   return jresult;
37409 }
37410
37411
37412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37413   void * jresult ;
37414   Dali::AlphaFunction *result = 0 ;
37415
37416   {
37417     try {
37418       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37426       };
37427     } catch (...) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37430       };
37431     }
37432   }
37433   jresult = (void *)result;
37434   return jresult;
37435 }
37436
37437
37438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37439   void * jresult ;
37440   Dali::AlphaFunction::BuiltinFunction arg1 ;
37441   Dali::AlphaFunction *result = 0 ;
37442
37443   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37444   {
37445     try {
37446       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37447     } catch (std::out_of_range& e) {
37448       {
37449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37450       };
37451     } catch (std::exception& e) {
37452       {
37453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37454       };
37455     } catch (...) {
37456       {
37457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37458       };
37459     }
37460   }
37461   jresult = (void *)result;
37462   return jresult;
37463 }
37464
37465
37466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37467   void * jresult ;
37468   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37469   Dali::AlphaFunction *result = 0 ;
37470
37471   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37472   {
37473     try {
37474       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37475     } catch (std::out_of_range& e) {
37476       {
37477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37478       };
37479     } catch (std::exception& e) {
37480       {
37481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37482       };
37483     } catch (...) {
37484       {
37485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37486       };
37487     }
37488   }
37489   jresult = (void *)result;
37490   return jresult;
37491 }
37492
37493
37494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37495   void * jresult ;
37496   Dali::Vector2 *arg1 = 0 ;
37497   Dali::Vector2 *arg2 = 0 ;
37498   Dali::AlphaFunction *result = 0 ;
37499
37500   arg1 = (Dali::Vector2 *)jarg1;
37501   if (!arg1) {
37502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37503     return 0;
37504   }
37505   arg2 = (Dali::Vector2 *)jarg2;
37506   if (!arg2) {
37507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37508     return 0;
37509   }
37510   {
37511     try {
37512       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37513     } catch (std::out_of_range& e) {
37514       {
37515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37516       };
37517     } catch (std::exception& e) {
37518       {
37519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37520       };
37521     } catch (...) {
37522       {
37523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37524       };
37525     }
37526   }
37527   jresult = (void *)result;
37528   return jresult;
37529 }
37530
37531
37532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37533   void * jresult ;
37534   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37535   Dali::Vector4 result;
37536
37537   arg1 = (Dali::AlphaFunction *)jarg1;
37538   {
37539     try {
37540       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37541     } catch (std::out_of_range& e) {
37542       {
37543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37544       };
37545     } catch (std::exception& e) {
37546       {
37547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37548       };
37549     } catch (...) {
37550       {
37551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37552       };
37553     }
37554   }
37555   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37556   return jresult;
37557 }
37558
37559
37560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37561   void * jresult ;
37562   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37563   Dali::AlphaFunctionPrototype result;
37564
37565   arg1 = (Dali::AlphaFunction *)jarg1;
37566   {
37567     try {
37568       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37569     } catch (std::out_of_range& e) {
37570       {
37571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37572       };
37573     } catch (std::exception& e) {
37574       {
37575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37576       };
37577     } catch (...) {
37578       {
37579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37580       };
37581     }
37582   }
37583   jresult = (void *)result;
37584   return jresult;
37585 }
37586
37587
37588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37589   int jresult ;
37590   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37591   Dali::AlphaFunction::BuiltinFunction result;
37592
37593   arg1 = (Dali::AlphaFunction *)jarg1;
37594   {
37595     try {
37596       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37597     } catch (std::out_of_range& e) {
37598       {
37599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37600       };
37601     } catch (std::exception& e) {
37602       {
37603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37604       };
37605     } catch (...) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37608       };
37609     }
37610   }
37611   jresult = (int)result;
37612   return jresult;
37613 }
37614
37615
37616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37617   int jresult ;
37618   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37619   Dali::AlphaFunction::Mode result;
37620
37621   arg1 = (Dali::AlphaFunction *)jarg1;
37622   {
37623     try {
37624       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37625     } catch (std::out_of_range& e) {
37626       {
37627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37628       };
37629     } catch (std::exception& e) {
37630       {
37631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37632       };
37633     } catch (...) {
37634       {
37635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37636       };
37637     }
37638   }
37639   jresult = (int)result;
37640   return jresult;
37641 }
37642
37643
37644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37645   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37646
37647   arg1 = (Dali::AlphaFunction *)jarg1;
37648   {
37649     try {
37650       delete arg1;
37651     } catch (std::out_of_range& e) {
37652       {
37653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37654       };
37655     } catch (std::exception& e) {
37656       {
37657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37658       };
37659     } catch (...) {
37660       {
37661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37662       };
37663     }
37664   }
37665 }
37666
37667
37668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37669   void * jresult ;
37670   Dali::KeyFrames result;
37671
37672   {
37673     try {
37674       result = Dali::KeyFrames::New();
37675     } catch (std::out_of_range& e) {
37676       {
37677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37678       };
37679     } catch (std::exception& e) {
37680       {
37681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37682       };
37683     } catch (...) {
37684       {
37685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37686       };
37687     }
37688   }
37689   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37690   return jresult;
37691 }
37692
37693
37694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37695   void * jresult ;
37696   Dali::BaseHandle arg1 ;
37697   Dali::BaseHandle *argp1 ;
37698   Dali::KeyFrames result;
37699
37700   argp1 = (Dali::BaseHandle *)jarg1;
37701   if (!argp1) {
37702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37703     return 0;
37704   }
37705   arg1 = *argp1;
37706   {
37707     try {
37708       result = Dali::KeyFrames::DownCast(arg1);
37709     } catch (std::out_of_range& e) {
37710       {
37711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37712       };
37713     } catch (std::exception& e) {
37714       {
37715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37716       };
37717     } catch (...) {
37718       {
37719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37720       };
37721     }
37722   }
37723   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37724   return jresult;
37725 }
37726
37727
37728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37729   void * jresult ;
37730   Dali::KeyFrames *result = 0 ;
37731
37732   {
37733     try {
37734       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37735     } catch (std::out_of_range& e) {
37736       {
37737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37738       };
37739     } catch (std::exception& e) {
37740       {
37741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37742       };
37743     } catch (...) {
37744       {
37745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37746       };
37747     }
37748   }
37749   jresult = (void *)result;
37750   return jresult;
37751 }
37752
37753
37754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37755   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37756
37757   arg1 = (Dali::KeyFrames *)jarg1;
37758   {
37759     try {
37760       delete arg1;
37761     } catch (std::out_of_range& e) {
37762       {
37763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37764       };
37765     } catch (std::exception& e) {
37766       {
37767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37768       };
37769     } catch (...) {
37770       {
37771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37772       };
37773     }
37774   }
37775 }
37776
37777
37778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37779   void * jresult ;
37780   Dali::KeyFrames *arg1 = 0 ;
37781   Dali::KeyFrames *result = 0 ;
37782
37783   arg1 = (Dali::KeyFrames *)jarg1;
37784   if (!arg1) {
37785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37786     return 0;
37787   }
37788   {
37789     try {
37790       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37798       };
37799     } catch (...) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37802       };
37803     }
37804   }
37805   jresult = (void *)result;
37806   return jresult;
37807 }
37808
37809
37810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37811   void * jresult ;
37812   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37813   Dali::KeyFrames *arg2 = 0 ;
37814   Dali::KeyFrames *result = 0 ;
37815
37816   arg1 = (Dali::KeyFrames *)jarg1;
37817   arg2 = (Dali::KeyFrames *)jarg2;
37818   if (!arg2) {
37819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37820     return 0;
37821   }
37822   {
37823     try {
37824       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37825     } catch (std::out_of_range& e) {
37826       {
37827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37828       };
37829     } catch (std::exception& e) {
37830       {
37831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37832       };
37833     } catch (...) {
37834       {
37835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37836       };
37837     }
37838   }
37839   jresult = (void *)result;
37840   return jresult;
37841 }
37842
37843
37844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37845   int jresult ;
37846   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37847   Dali::Property::Type result;
37848
37849   arg1 = (Dali::KeyFrames *)jarg1;
37850   {
37851     try {
37852       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37853     } catch (std::out_of_range& e) {
37854       {
37855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37856       };
37857     } catch (std::exception& e) {
37858       {
37859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37860       };
37861     } catch (...) {
37862       {
37863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37864       };
37865     }
37866   }
37867   jresult = (int)result;
37868   return jresult;
37869 }
37870
37871
37872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37873   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37874   float arg2 ;
37875   Dali::Property::Value arg3 ;
37876   Dali::Property::Value *argp3 ;
37877
37878   arg1 = (Dali::KeyFrames *)jarg1;
37879   arg2 = (float)jarg2;
37880   argp3 = (Dali::Property::Value *)jarg3;
37881   if (!argp3) {
37882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37883     return ;
37884   }
37885   arg3 = *argp3;
37886   {
37887     try {
37888       (arg1)->Add(arg2,arg3);
37889     } catch (std::out_of_range& e) {
37890       {
37891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37892       };
37893     } catch (std::exception& e) {
37894       {
37895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37896       };
37897     } catch (...) {
37898       {
37899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37900       };
37901     }
37902   }
37903 }
37904
37905
37906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37907   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37908   float arg2 ;
37909   Dali::Property::Value arg3 ;
37910   Dali::AlphaFunction arg4 ;
37911   Dali::Property::Value *argp3 ;
37912   Dali::AlphaFunction *argp4 ;
37913
37914   arg1 = (Dali::KeyFrames *)jarg1;
37915   arg2 = (float)jarg2;
37916   argp3 = (Dali::Property::Value *)jarg3;
37917   if (!argp3) {
37918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37919     return ;
37920   }
37921   arg3 = *argp3;
37922   argp4 = (Dali::AlphaFunction *)jarg4;
37923   if (!argp4) {
37924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37925     return ;
37926   }
37927   arg4 = *argp4;
37928   {
37929     try {
37930       (arg1)->Add(arg2,arg3,arg4);
37931     } catch (std::out_of_range& e) {
37932       {
37933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37934       };
37935     } catch (std::exception& e) {
37936       {
37937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37942       };
37943     }
37944   }
37945 }
37946
37947
37948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37949   int jresult ;
37950   int result;
37951
37952   result = (int)Dali::Path::Property::POINTS;
37953   jresult = (int)result;
37954   return jresult;
37955 }
37956
37957
37958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37959   int jresult ;
37960   int result;
37961
37962   result = (int)Dali::Path::Property::CONTROL_POINTS;
37963   jresult = (int)result;
37964   return jresult;
37965 }
37966
37967
37968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37969   void * jresult ;
37970   Dali::Path::Property *result = 0 ;
37971
37972   {
37973     try {
37974       result = (Dali::Path::Property *)new Dali::Path::Property();
37975     } catch (std::out_of_range& e) {
37976       {
37977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37978       };
37979     } catch (std::exception& e) {
37980       {
37981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37982       };
37983     } catch (...) {
37984       {
37985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37986       };
37987     }
37988   }
37989   jresult = (void *)result;
37990   return jresult;
37991 }
37992
37993
37994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37995   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37996
37997   arg1 = (Dali::Path::Property *)jarg1;
37998   {
37999     try {
38000       delete arg1;
38001     } catch (std::out_of_range& e) {
38002       {
38003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38004       };
38005     } catch (std::exception& e) {
38006       {
38007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38008       };
38009     } catch (...) {
38010       {
38011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38012       };
38013     }
38014   }
38015 }
38016
38017
38018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38019   void * jresult ;
38020   Dali::Path result;
38021
38022   {
38023     try {
38024       result = Dali::Path::New();
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (...) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38036       };
38037     }
38038   }
38039   jresult = new Dali::Path((const Dali::Path &)result);
38040   return jresult;
38041 }
38042
38043
38044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38045   void * jresult ;
38046   Dali::BaseHandle arg1 ;
38047   Dali::BaseHandle *argp1 ;
38048   Dali::Path result;
38049
38050   argp1 = (Dali::BaseHandle *)jarg1;
38051   if (!argp1) {
38052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38053     return 0;
38054   }
38055   arg1 = *argp1;
38056   {
38057     try {
38058       result = Dali::Path::DownCast(arg1);
38059     } catch (std::out_of_range& e) {
38060       {
38061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38062       };
38063     } catch (std::exception& e) {
38064       {
38065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38066       };
38067     } catch (...) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38070       };
38071     }
38072   }
38073   jresult = new Dali::Path((const Dali::Path &)result);
38074   return jresult;
38075 }
38076
38077
38078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38079   void * jresult ;
38080   Dali::Path *result = 0 ;
38081
38082   {
38083     try {
38084       result = (Dali::Path *)new Dali::Path();
38085     } catch (std::out_of_range& e) {
38086       {
38087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38088       };
38089     } catch (std::exception& e) {
38090       {
38091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (...) {
38094       {
38095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38096       };
38097     }
38098   }
38099   jresult = (void *)result;
38100   return jresult;
38101 }
38102
38103
38104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38105   Dali::Path *arg1 = (Dali::Path *) 0 ;
38106
38107   arg1 = (Dali::Path *)jarg1;
38108   {
38109     try {
38110       delete arg1;
38111     } catch (std::out_of_range& e) {
38112       {
38113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38114       };
38115     } catch (std::exception& e) {
38116       {
38117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38118       };
38119     } catch (...) {
38120       {
38121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38122       };
38123     }
38124   }
38125 }
38126
38127
38128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38129   void * jresult ;
38130   Dali::Path *arg1 = 0 ;
38131   Dali::Path *result = 0 ;
38132
38133   arg1 = (Dali::Path *)jarg1;
38134   if (!arg1) {
38135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38136     return 0;
38137   }
38138   {
38139     try {
38140       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38141     } catch (std::out_of_range& e) {
38142       {
38143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38144       };
38145     } catch (std::exception& e) {
38146       {
38147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38148       };
38149     } catch (...) {
38150       {
38151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38152       };
38153     }
38154   }
38155   jresult = (void *)result;
38156   return jresult;
38157 }
38158
38159
38160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38161   void * jresult ;
38162   Dali::Path *arg1 = (Dali::Path *) 0 ;
38163   Dali::Path *arg2 = 0 ;
38164   Dali::Path *result = 0 ;
38165
38166   arg1 = (Dali::Path *)jarg1;
38167   arg2 = (Dali::Path *)jarg2;
38168   if (!arg2) {
38169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38170     return 0;
38171   }
38172   {
38173     try {
38174       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38175     } catch (std::out_of_range& e) {
38176       {
38177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38178       };
38179     } catch (std::exception& e) {
38180       {
38181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38182       };
38183     } catch (...) {
38184       {
38185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38186       };
38187     }
38188   }
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38195   Dali::Path *arg1 = (Dali::Path *) 0 ;
38196   Dali::Vector3 *arg2 = 0 ;
38197
38198   arg1 = (Dali::Path *)jarg1;
38199   arg2 = (Dali::Vector3 *)jarg2;
38200   if (!arg2) {
38201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38202     return ;
38203   }
38204   {
38205     try {
38206       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38207     } catch (std::out_of_range& e) {
38208       {
38209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38210       };
38211     } catch (std::exception& e) {
38212       {
38213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38218       };
38219     }
38220   }
38221 }
38222
38223
38224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38225   Dali::Path *arg1 = (Dali::Path *) 0 ;
38226   Dali::Vector3 *arg2 = 0 ;
38227
38228   arg1 = (Dali::Path *)jarg1;
38229   arg2 = (Dali::Vector3 *)jarg2;
38230   if (!arg2) {
38231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38232     return ;
38233   }
38234   {
38235     try {
38236       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38237     } catch (std::out_of_range& e) {
38238       {
38239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38240       };
38241     } catch (std::exception& e) {
38242       {
38243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38244       };
38245     } catch (...) {
38246       {
38247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38248       };
38249     }
38250   }
38251 }
38252
38253
38254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38255   Dali::Path *arg1 = (Dali::Path *) 0 ;
38256   float arg2 ;
38257
38258   arg1 = (Dali::Path *)jarg1;
38259   arg2 = (float)jarg2;
38260   {
38261     try {
38262       (arg1)->GenerateControlPoints(arg2);
38263     } catch (std::out_of_range& e) {
38264       {
38265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38266       };
38267     } catch (std::exception& e) {
38268       {
38269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38270       };
38271     } catch (...) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38274       };
38275     }
38276   }
38277 }
38278
38279
38280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38281   Dali::Path *arg1 = (Dali::Path *) 0 ;
38282   float arg2 ;
38283   Dali::Vector3 *arg3 = 0 ;
38284   Dali::Vector3 *arg4 = 0 ;
38285
38286   arg1 = (Dali::Path *)jarg1;
38287   arg2 = (float)jarg2;
38288   arg3 = (Dali::Vector3 *)jarg3;
38289   if (!arg3) {
38290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38291     return ;
38292   }
38293   arg4 = (Dali::Vector3 *)jarg4;
38294   if (!arg4) {
38295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38296     return ;
38297   }
38298   {
38299     try {
38300       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38301     } catch (std::out_of_range& e) {
38302       {
38303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38304       };
38305     } catch (std::exception& e) {
38306       {
38307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38308       };
38309     } catch (...) {
38310       {
38311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38312       };
38313     }
38314   }
38315 }
38316
38317
38318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38319   void * jresult ;
38320   Dali::Path *arg1 = (Dali::Path *) 0 ;
38321   size_t arg2 ;
38322   Dali::Vector3 *result = 0 ;
38323
38324   arg1 = (Dali::Path *)jarg1;
38325   arg2 = (size_t)jarg2;
38326   {
38327     try {
38328       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38329     } catch (std::out_of_range& e) {
38330       {
38331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38332       };
38333     } catch (std::exception& e) {
38334       {
38335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38336       };
38337     } catch (...) {
38338       {
38339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38340       };
38341     }
38342   }
38343   jresult = (void *)result;
38344   return jresult;
38345 }
38346
38347
38348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38349   void * jresult ;
38350   Dali::Path *arg1 = (Dali::Path *) 0 ;
38351   size_t arg2 ;
38352   Dali::Vector3 *result = 0 ;
38353
38354   arg1 = (Dali::Path *)jarg1;
38355   arg2 = (size_t)jarg2;
38356   {
38357     try {
38358       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38359     } catch (std::out_of_range& e) {
38360       {
38361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38362       };
38363     } catch (std::exception& e) {
38364       {
38365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38366       };
38367     } catch (...) {
38368       {
38369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38370       };
38371     }
38372   }
38373   jresult = (void *)result;
38374   return jresult;
38375 }
38376
38377
38378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38379   unsigned long jresult ;
38380   Dali::Path *arg1 = (Dali::Path *) 0 ;
38381   size_t result;
38382
38383   arg1 = (Dali::Path *)jarg1;
38384   {
38385     try {
38386       result = ((Dali::Path const *)arg1)->GetPointCount();
38387     } catch (std::out_of_range& e) {
38388       {
38389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38390       };
38391     } catch (std::exception& e) {
38392       {
38393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38394       };
38395     } catch (...) {
38396       {
38397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38398       };
38399     }
38400   }
38401   jresult = (unsigned long)result;
38402   return jresult;
38403 }
38404
38405
38406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38407   void * jresult ;
38408   float arg1 ;
38409   Dali::TimePeriod *result = 0 ;
38410
38411   arg1 = (float)jarg1;
38412   {
38413     try {
38414       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38415     } catch (std::out_of_range& e) {
38416       {
38417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38418       };
38419     } catch (std::exception& e) {
38420       {
38421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38422       };
38423     } catch (...) {
38424       {
38425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38426       };
38427     }
38428   }
38429   jresult = (void *)result;
38430   return jresult;
38431 }
38432
38433
38434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38435   void * jresult ;
38436   float arg1 ;
38437   float arg2 ;
38438   Dali::TimePeriod *result = 0 ;
38439
38440   arg1 = (float)jarg1;
38441   arg2 = (float)jarg2;
38442   {
38443     try {
38444       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38445     } catch (std::out_of_range& e) {
38446       {
38447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38448       };
38449     } catch (std::exception& e) {
38450       {
38451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38452       };
38453     } catch (...) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38456       };
38457     }
38458   }
38459   jresult = (void *)result;
38460   return jresult;
38461 }
38462
38463
38464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38465   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38466
38467   arg1 = (Dali::TimePeriod *)jarg1;
38468   {
38469     try {
38470       delete arg1;
38471     } catch (std::out_of_range& e) {
38472       {
38473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38474       };
38475     } catch (std::exception& e) {
38476       {
38477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38478       };
38479     } catch (...) {
38480       {
38481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38482       };
38483     }
38484   }
38485 }
38486
38487
38488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38489   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38490   float arg2 ;
38491
38492   arg1 = (Dali::TimePeriod *)jarg1;
38493   arg2 = (float)jarg2;
38494   if (arg1) (arg1)->delaySeconds = arg2;
38495 }
38496
38497
38498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38499   float jresult ;
38500   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38501   float result;
38502
38503   arg1 = (Dali::TimePeriod *)jarg1;
38504   result = (float) ((arg1)->delaySeconds);
38505   jresult = result;
38506   return jresult;
38507 }
38508
38509
38510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38511   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38512   float arg2 ;
38513
38514   arg1 = (Dali::TimePeriod *)jarg1;
38515   arg2 = (float)jarg2;
38516   if (arg1) (arg1)->durationSeconds = arg2;
38517 }
38518
38519
38520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38521   float jresult ;
38522   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38523   float result;
38524
38525   arg1 = (Dali::TimePeriod *)jarg1;
38526   result = (float) ((arg1)->durationSeconds);
38527   jresult = result;
38528   return jresult;
38529 }
38530
38531
38532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38533   void * jresult ;
38534   Dali::Animation *result = 0 ;
38535
38536   {
38537     try {
38538       result = (Dali::Animation *)new Dali::Animation();
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (...) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38550       };
38551     }
38552   }
38553   jresult = (void *)result;
38554   return jresult;
38555 }
38556
38557
38558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38559   void * jresult ;
38560   float arg1 ;
38561   Dali::Animation result;
38562
38563   arg1 = (float)jarg1;
38564   {
38565     try {
38566       result = Dali::Animation::New(arg1);
38567     } catch (std::out_of_range& e) {
38568       {
38569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (std::exception& e) {
38572       {
38573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581   jresult = new Dali::Animation((const Dali::Animation &)result);
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38587   void * jresult ;
38588   Dali::BaseHandle arg1 ;
38589   Dali::BaseHandle *argp1 ;
38590   Dali::Animation result;
38591
38592   argp1 = (Dali::BaseHandle *)jarg1;
38593   if (!argp1) {
38594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38595     return 0;
38596   }
38597   arg1 = *argp1;
38598   {
38599     try {
38600       result = Dali::Animation::DownCast(arg1);
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 (...) {
38610       {
38611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38612       };
38613     }
38614   }
38615   jresult = new Dali::Animation((const Dali::Animation &)result);
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38621   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38622
38623   arg1 = (Dali::Animation *)jarg1;
38624   {
38625     try {
38626       delete arg1;
38627     } catch (std::out_of_range& e) {
38628       {
38629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38630       };
38631     } catch (std::exception& e) {
38632       {
38633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38634       };
38635     } catch (...) {
38636       {
38637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38638       };
38639     }
38640   }
38641 }
38642
38643
38644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38645   void * jresult ;
38646   Dali::Animation *arg1 = 0 ;
38647   Dali::Animation *result = 0 ;
38648
38649   arg1 = (Dali::Animation *)jarg1;
38650   if (!arg1) {
38651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38652     return 0;
38653   }
38654   {
38655     try {
38656       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38657     } catch (std::out_of_range& e) {
38658       {
38659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38660       };
38661     } catch (std::exception& e) {
38662       {
38663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38668       };
38669     }
38670   }
38671   jresult = (void *)result;
38672   return jresult;
38673 }
38674
38675
38676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38677   void * jresult ;
38678   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38679   Dali::Animation *arg2 = 0 ;
38680   Dali::Animation *result = 0 ;
38681
38682   arg1 = (Dali::Animation *)jarg1;
38683   arg2 = (Dali::Animation *)jarg2;
38684   if (!arg2) {
38685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38686     return 0;
38687   }
38688   {
38689     try {
38690       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38691     } catch (std::out_of_range& e) {
38692       {
38693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38694       };
38695     } catch (std::exception& e) {
38696       {
38697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (...) {
38700       {
38701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38702       };
38703     }
38704   }
38705   jresult = (void *)result;
38706   return jresult;
38707 }
38708
38709
38710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38711   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38712   float arg2 ;
38713
38714   arg1 = (Dali::Animation *)jarg1;
38715   arg2 = (float)jarg2;
38716   {
38717     try {
38718       (arg1)->SetDuration(arg2);
38719     } catch (std::out_of_range& e) {
38720       {
38721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38722       };
38723     } catch (std::exception& e) {
38724       {
38725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38730       };
38731     }
38732   }
38733 }
38734
38735
38736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38737   float jresult ;
38738   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38739   float result;
38740
38741   arg1 = (Dali::Animation *)jarg1;
38742   {
38743     try {
38744       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38745     } catch (std::out_of_range& e) {
38746       {
38747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38748       };
38749     } catch (std::exception& e) {
38750       {
38751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38752       };
38753     } catch (...) {
38754       {
38755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38756       };
38757     }
38758   }
38759   jresult = result;
38760   return jresult;
38761 }
38762
38763
38764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38765   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38766   bool arg2 ;
38767
38768   arg1 = (Dali::Animation *)jarg1;
38769   arg2 = jarg2 ? true : false;
38770   {
38771     try {
38772       (arg1)->SetLooping(arg2);
38773     } catch (std::out_of_range& e) {
38774       {
38775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38776       };
38777     } catch (std::exception& e) {
38778       {
38779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38780       };
38781     } catch (...) {
38782       {
38783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38784       };
38785     }
38786   }
38787 }
38788
38789
38790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38791   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38792   int arg2 ;
38793
38794   arg1 = (Dali::Animation *)jarg1;
38795   arg2 = (int)jarg2;
38796   {
38797     try {
38798       (arg1)->SetLoopCount(arg2);
38799     } catch (std::out_of_range& e) {
38800       {
38801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38802       };
38803     } catch (std::exception& e) {
38804       {
38805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38806       };
38807     } catch (...) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38810       };
38811     }
38812   }
38813 }
38814
38815
38816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38817   int jresult ;
38818   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38819   int result;
38820
38821   arg1 = (Dali::Animation *)jarg1;
38822   {
38823     try {
38824       result = (int)(arg1)->GetLoopCount();
38825     } catch (std::out_of_range& e) {
38826       {
38827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38828       };
38829     } catch (std::exception& e) {
38830       {
38831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38832       };
38833     } catch (...) {
38834       {
38835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38836       };
38837     }
38838   }
38839   jresult = result;
38840   return jresult;
38841 }
38842
38843
38844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38845   int jresult ;
38846   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38847   int result;
38848
38849   arg1 = (Dali::Animation *)jarg1;
38850   {
38851     try {
38852       result = (int)(arg1)->GetCurrentLoop();
38853     } catch (std::out_of_range& e) {
38854       {
38855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38856       };
38857     } catch (std::exception& e) {
38858       {
38859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (...) {
38862       {
38863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38864       };
38865     }
38866   }
38867   jresult = result;
38868   return jresult;
38869 }
38870
38871
38872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38873   unsigned int jresult ;
38874   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38875   bool result;
38876
38877   arg1 = (Dali::Animation *)jarg1;
38878   {
38879     try {
38880       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38881     } catch (std::out_of_range& e) {
38882       {
38883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38884       };
38885     } catch (std::exception& e) {
38886       {
38887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38888       };
38889     } catch (...) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38892       };
38893     }
38894   }
38895   jresult = result;
38896   return jresult;
38897 }
38898
38899
38900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38902   Dali::Animation::EndAction arg2 ;
38903
38904   arg1 = (Dali::Animation *)jarg1;
38905   arg2 = (Dali::Animation::EndAction)jarg2;
38906   {
38907     try {
38908       (arg1)->SetEndAction(arg2);
38909     } catch (std::out_of_range& e) {
38910       {
38911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38912       };
38913     } catch (std::exception& e) {
38914       {
38915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38916       };
38917     } catch (...) {
38918       {
38919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38920       };
38921     }
38922   }
38923 }
38924
38925
38926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38927   int jresult ;
38928   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38929   Dali::Animation::EndAction result;
38930
38931   arg1 = (Dali::Animation *)jarg1;
38932   {
38933     try {
38934       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38935     } catch (std::out_of_range& e) {
38936       {
38937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38938       };
38939     } catch (std::exception& e) {
38940       {
38941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38942       };
38943     } catch (...) {
38944       {
38945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38946       };
38947     }
38948   }
38949   jresult = (int)result;
38950   return jresult;
38951 }
38952
38953
38954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38955   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38956   Dali::Animation::EndAction arg2 ;
38957
38958   arg1 = (Dali::Animation *)jarg1;
38959   arg2 = (Dali::Animation::EndAction)jarg2;
38960   {
38961     try {
38962       (arg1)->SetDisconnectAction(arg2);
38963     } catch (std::out_of_range& e) {
38964       {
38965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38966       };
38967     } catch (std::exception& e) {
38968       {
38969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38970       };
38971     } catch (...) {
38972       {
38973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38974       };
38975     }
38976   }
38977 }
38978
38979
38980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38981   int jresult ;
38982   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38983   Dali::Animation::EndAction result;
38984
38985   arg1 = (Dali::Animation *)jarg1;
38986   {
38987     try {
38988       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38989     } catch (std::out_of_range& e) {
38990       {
38991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38992       };
38993     } catch (std::exception& e) {
38994       {
38995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38996       };
38997     } catch (...) {
38998       {
38999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39000       };
39001     }
39002   }
39003   jresult = (int)result;
39004   return jresult;
39005 }
39006
39007
39008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39009   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39010   Dali::AlphaFunction arg2 ;
39011   Dali::AlphaFunction *argp2 ;
39012
39013   arg1 = (Dali::Animation *)jarg1;
39014   argp2 = (Dali::AlphaFunction *)jarg2;
39015   if (!argp2) {
39016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39017     return ;
39018   }
39019   arg2 = *argp2;
39020   {
39021     try {
39022       (arg1)->SetDefaultAlphaFunction(arg2);
39023     } catch (std::out_of_range& e) {
39024       {
39025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39026       };
39027     } catch (std::exception& e) {
39028       {
39029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39030       };
39031     } catch (...) {
39032       {
39033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39034       };
39035     }
39036   }
39037 }
39038
39039
39040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39041   void * jresult ;
39042   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39043   Dali::AlphaFunction result;
39044
39045   arg1 = (Dali::Animation *)jarg1;
39046   {
39047     try {
39048       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39049     } catch (std::out_of_range& e) {
39050       {
39051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39052       };
39053     } catch (std::exception& e) {
39054       {
39055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39056       };
39057     } catch (...) {
39058       {
39059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39060       };
39061     }
39062   }
39063   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39064   return jresult;
39065 }
39066
39067
39068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39069   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39070   float arg2 ;
39071
39072   arg1 = (Dali::Animation *)jarg1;
39073   arg2 = (float)jarg2;
39074   {
39075     try {
39076       (arg1)->SetCurrentProgress(arg2);
39077     } catch (std::out_of_range& e) {
39078       {
39079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39080       };
39081     } catch (std::exception& e) {
39082       {
39083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39084       };
39085     } catch (...) {
39086       {
39087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39088       };
39089     }
39090   }
39091 }
39092
39093
39094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39095   float jresult ;
39096   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39097   float result;
39098
39099   arg1 = (Dali::Animation *)jarg1;
39100   {
39101     try {
39102       result = (float)(arg1)->GetCurrentProgress();
39103     } catch (std::out_of_range& e) {
39104       {
39105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39106       };
39107     } catch (std::exception& e) {
39108       {
39109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39110       };
39111     } catch (...) {
39112       {
39113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39114       };
39115     }
39116   }
39117   jresult = result;
39118   return jresult;
39119 }
39120
39121
39122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39123   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39124   float arg2 ;
39125
39126   arg1 = (Dali::Animation *)jarg1;
39127   arg2 = (float)jarg2;
39128   {
39129     try {
39130       (arg1)->SetSpeedFactor(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 (...) {
39140       {
39141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39142       };
39143     }
39144   }
39145 }
39146
39147
39148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39149   float jresult ;
39150   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39151   float result;
39152
39153   arg1 = (Dali::Animation *)jarg1;
39154   {
39155     try {
39156       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39157     } catch (std::out_of_range& e) {
39158       {
39159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39160       };
39161     } catch (std::exception& e) {
39162       {
39163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39164       };
39165     } catch (...) {
39166       {
39167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39168       };
39169     }
39170   }
39171   jresult = result;
39172   return jresult;
39173 }
39174
39175
39176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39177   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39178   Dali::Vector2 *arg2 = 0 ;
39179
39180   arg1 = (Dali::Animation *)jarg1;
39181   arg2 = (Dali::Vector2 *)jarg2;
39182   if (!arg2) {
39183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39184     return ;
39185   }
39186   {
39187     try {
39188       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39189     } catch (std::out_of_range& e) {
39190       {
39191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39192       };
39193     } catch (std::exception& e) {
39194       {
39195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39196       };
39197     } catch (...) {
39198       {
39199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39200       };
39201     }
39202   }
39203 }
39204
39205
39206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39207   void * jresult ;
39208   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39209   Dali::Vector2 result;
39210
39211   arg1 = (Dali::Animation *)jarg1;
39212   {
39213     try {
39214       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39215     } catch (std::out_of_range& e) {
39216       {
39217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (std::exception& e) {
39220       {
39221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39230   return jresult;
39231 }
39232
39233
39234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39235   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39236
39237   arg1 = (Dali::Animation *)jarg1;
39238   {
39239     try {
39240       (arg1)->Play();
39241     } catch (std::out_of_range& e) {
39242       {
39243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39244       };
39245     } catch (std::exception& e) {
39246       {
39247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39248       };
39249     } catch (...) {
39250       {
39251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39252       };
39253     }
39254   }
39255 }
39256
39257
39258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39259   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39260   float arg2 ;
39261
39262   arg1 = (Dali::Animation *)jarg1;
39263   arg2 = (float)jarg2;
39264   {
39265     try {
39266       (arg1)->PlayFrom(arg2);
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (...) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39278       };
39279     }
39280   }
39281 }
39282
39283
39284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39285   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39286
39287   arg1 = (Dali::Animation *)jarg1;
39288   {
39289     try {
39290       (arg1)->Pause();
39291     } catch (std::out_of_range& e) {
39292       {
39293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39294       };
39295     } catch (std::exception& e) {
39296       {
39297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39298       };
39299     } catch (...) {
39300       {
39301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39302       };
39303     }
39304   }
39305 }
39306
39307
39308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39309   int jresult ;
39310   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39311   Dali::Animation::State result;
39312
39313   arg1 = (Dali::Animation *)jarg1;
39314   {
39315     try {
39316       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39317     } catch (std::out_of_range& e) {
39318       {
39319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39320       };
39321     } catch (std::exception& e) {
39322       {
39323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39324       };
39325     } catch (...) {
39326       {
39327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39328       };
39329     }
39330   }
39331   jresult = (int)result;
39332   return jresult;
39333 }
39334
39335
39336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39337   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39338
39339   arg1 = (Dali::Animation *)jarg1;
39340   {
39341     try {
39342       (arg1)->Stop();
39343     } catch (std::out_of_range& e) {
39344       {
39345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39346       };
39347     } catch (std::exception& e) {
39348       {
39349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39350       };
39351     } catch (...) {
39352       {
39353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39354       };
39355     }
39356   }
39357 }
39358
39359
39360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39361   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39362
39363   arg1 = (Dali::Animation *)jarg1;
39364   {
39365     try {
39366       (arg1)->Clear();
39367     } catch (std::out_of_range& e) {
39368       {
39369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39370       };
39371     } catch (std::exception& e) {
39372       {
39373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39374       };
39375     } catch (...) {
39376       {
39377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39378       };
39379     }
39380   }
39381 }
39382
39383
39384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39385   void * jresult ;
39386   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39387   Dali::Animation::AnimationSignalType *result = 0 ;
39388
39389   arg1 = (Dali::Animation *)jarg1;
39390   {
39391     try {
39392       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39393     } catch (std::out_of_range& e) {
39394       {
39395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39396       };
39397     } catch (std::exception& e) {
39398       {
39399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39400       };
39401     } catch (...) {
39402       {
39403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39404       };
39405     }
39406   }
39407   jresult = (void *)result;
39408   return jresult;
39409 }
39410
39411
39412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39413   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39414   SwigValueWrapper< Dali::Property > arg2 ;
39415   Dali::Property::Value arg3 ;
39416   Dali::Property *argp2 ;
39417   Dali::Property::Value *argp3 ;
39418
39419   arg1 = (Dali::Animation *)jarg1;
39420   argp2 = (Dali::Property *)jarg2;
39421   if (!argp2) {
39422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39423     return ;
39424   }
39425   arg2 = *argp2;
39426   argp3 = (Dali::Property::Value *)jarg3;
39427   if (!argp3) {
39428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39429     return ;
39430   }
39431   arg3 = *argp3;
39432   {
39433     try {
39434       (arg1)->AnimateBy(arg2,arg3);
39435     } catch (std::out_of_range& e) {
39436       {
39437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (std::exception& e) {
39440       {
39441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39442       };
39443     } catch (...) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39446       };
39447     }
39448   }
39449 }
39450
39451
39452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39453   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39454   SwigValueWrapper< Dali::Property > arg2 ;
39455   Dali::Property::Value arg3 ;
39456   Dali::AlphaFunction arg4 ;
39457   Dali::Property *argp2 ;
39458   Dali::Property::Value *argp3 ;
39459   Dali::AlphaFunction *argp4 ;
39460
39461   arg1 = (Dali::Animation *)jarg1;
39462   argp2 = (Dali::Property *)jarg2;
39463   if (!argp2) {
39464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39465     return ;
39466   }
39467   arg2 = *argp2;
39468   argp3 = (Dali::Property::Value *)jarg3;
39469   if (!argp3) {
39470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39471     return ;
39472   }
39473   arg3 = *argp3;
39474   argp4 = (Dali::AlphaFunction *)jarg4;
39475   if (!argp4) {
39476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39477     return ;
39478   }
39479   arg4 = *argp4;
39480   {
39481     try {
39482       (arg1)->AnimateBy(arg2,arg3,arg4);
39483     } catch (std::out_of_range& e) {
39484       {
39485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39486       };
39487     } catch (std::exception& e) {
39488       {
39489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39490       };
39491     } catch (...) {
39492       {
39493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39494       };
39495     }
39496   }
39497 }
39498
39499
39500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39501   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39502   SwigValueWrapper< Dali::Property > arg2 ;
39503   Dali::Property::Value arg3 ;
39504   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39505   Dali::Property *argp2 ;
39506   Dali::Property::Value *argp3 ;
39507   Dali::TimePeriod *argp4 ;
39508
39509   arg1 = (Dali::Animation *)jarg1;
39510   argp2 = (Dali::Property *)jarg2;
39511   if (!argp2) {
39512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39513     return ;
39514   }
39515   arg2 = *argp2;
39516   argp3 = (Dali::Property::Value *)jarg3;
39517   if (!argp3) {
39518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39519     return ;
39520   }
39521   arg3 = *argp3;
39522   argp4 = (Dali::TimePeriod *)jarg4;
39523   if (!argp4) {
39524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39525     return ;
39526   }
39527   arg4 = *argp4;
39528   {
39529     try {
39530       (arg1)->AnimateBy(arg2,arg3,arg4);
39531     } catch (std::out_of_range& e) {
39532       {
39533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39534       };
39535     } catch (std::exception& e) {
39536       {
39537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39538       };
39539     } catch (...) {
39540       {
39541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39542       };
39543     }
39544   }
39545 }
39546
39547
39548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39549   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39550   SwigValueWrapper< Dali::Property > arg2 ;
39551   Dali::Property::Value arg3 ;
39552   Dali::AlphaFunction arg4 ;
39553   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39554   Dali::Property *argp2 ;
39555   Dali::Property::Value *argp3 ;
39556   Dali::AlphaFunction *argp4 ;
39557   Dali::TimePeriod *argp5 ;
39558
39559   arg1 = (Dali::Animation *)jarg1;
39560   argp2 = (Dali::Property *)jarg2;
39561   if (!argp2) {
39562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39563     return ;
39564   }
39565   arg2 = *argp2;
39566   argp3 = (Dali::Property::Value *)jarg3;
39567   if (!argp3) {
39568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39569     return ;
39570   }
39571   arg3 = *argp3;
39572   argp4 = (Dali::AlphaFunction *)jarg4;
39573   if (!argp4) {
39574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39575     return ;
39576   }
39577   arg4 = *argp4;
39578   argp5 = (Dali::TimePeriod *)jarg5;
39579   if (!argp5) {
39580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39581     return ;
39582   }
39583   arg5 = *argp5;
39584   {
39585     try {
39586       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39587     } catch (std::out_of_range& e) {
39588       {
39589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39590       };
39591     } catch (std::exception& e) {
39592       {
39593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39594       };
39595     } catch (...) {
39596       {
39597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39598       };
39599     }
39600   }
39601 }
39602
39603
39604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39605   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39606   SwigValueWrapper< Dali::Property > arg2 ;
39607   Dali::Property::Value arg3 ;
39608   Dali::Property *argp2 ;
39609   Dali::Property::Value *argp3 ;
39610
39611   arg1 = (Dali::Animation *)jarg1;
39612   argp2 = (Dali::Property *)jarg2;
39613   if (!argp2) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39615     return ;
39616   }
39617   arg2 = *argp2;
39618   argp3 = (Dali::Property::Value *)jarg3;
39619   if (!argp3) {
39620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39621     return ;
39622   }
39623   arg3 = *argp3;
39624   {
39625     try {
39626       (arg1)->AnimateTo(arg2,arg3);
39627     } catch (std::out_of_range& e) {
39628       {
39629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39630       };
39631     } catch (std::exception& e) {
39632       {
39633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39634       };
39635     } catch (...) {
39636       {
39637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39638       };
39639     }
39640   }
39641 }
39642
39643
39644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39645   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39646   SwigValueWrapper< Dali::Property > arg2 ;
39647   Dali::Property::Value arg3 ;
39648   Dali::AlphaFunction arg4 ;
39649   Dali::Property *argp2 ;
39650   Dali::Property::Value *argp3 ;
39651   Dali::AlphaFunction *argp4 ;
39652
39653   arg1 = (Dali::Animation *)jarg1;
39654   argp2 = (Dali::Property *)jarg2;
39655   if (!argp2) {
39656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39657     return ;
39658   }
39659   arg2 = *argp2;
39660   argp3 = (Dali::Property::Value *)jarg3;
39661   if (!argp3) {
39662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39663     return ;
39664   }
39665   arg3 = *argp3;
39666   argp4 = (Dali::AlphaFunction *)jarg4;
39667   if (!argp4) {
39668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39669     return ;
39670   }
39671   arg4 = *argp4;
39672   {
39673     try {
39674       (arg1)->AnimateTo(arg2,arg3,arg4);
39675     } catch (std::out_of_range& e) {
39676       {
39677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39678       };
39679     } catch (std::exception& e) {
39680       {
39681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39682       };
39683     } catch (...) {
39684       {
39685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39686       };
39687     }
39688   }
39689 }
39690
39691
39692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39693   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39694   SwigValueWrapper< Dali::Property > arg2 ;
39695   Dali::Property::Value arg3 ;
39696   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39697   Dali::Property *argp2 ;
39698   Dali::Property::Value *argp3 ;
39699   Dali::TimePeriod *argp4 ;
39700
39701   arg1 = (Dali::Animation *)jarg1;
39702   argp2 = (Dali::Property *)jarg2;
39703   if (!argp2) {
39704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39705     return ;
39706   }
39707   arg2 = *argp2;
39708   argp3 = (Dali::Property::Value *)jarg3;
39709   if (!argp3) {
39710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39711     return ;
39712   }
39713   arg3 = *argp3;
39714   argp4 = (Dali::TimePeriod *)jarg4;
39715   if (!argp4) {
39716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39717     return ;
39718   }
39719   arg4 = *argp4;
39720   {
39721     try {
39722       (arg1)->AnimateTo(arg2,arg3,arg4);
39723     } catch (std::out_of_range& e) {
39724       {
39725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39726       };
39727     } catch (std::exception& e) {
39728       {
39729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39730       };
39731     } catch (...) {
39732       {
39733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39734       };
39735     }
39736   }
39737 }
39738
39739
39740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39741   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39742   SwigValueWrapper< Dali::Property > arg2 ;
39743   Dali::Property::Value arg3 ;
39744   Dali::AlphaFunction arg4 ;
39745   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39746   Dali::Property *argp2 ;
39747   Dali::Property::Value *argp3 ;
39748   Dali::AlphaFunction *argp4 ;
39749   Dali::TimePeriod *argp5 ;
39750
39751   arg1 = (Dali::Animation *)jarg1;
39752   argp2 = (Dali::Property *)jarg2;
39753   if (!argp2) {
39754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39755     return ;
39756   }
39757   arg2 = *argp2;
39758   argp3 = (Dali::Property::Value *)jarg3;
39759   if (!argp3) {
39760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39761     return ;
39762   }
39763   arg3 = *argp3;
39764   argp4 = (Dali::AlphaFunction *)jarg4;
39765   if (!argp4) {
39766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39767     return ;
39768   }
39769   arg4 = *argp4;
39770   argp5 = (Dali::TimePeriod *)jarg5;
39771   if (!argp5) {
39772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39773     return ;
39774   }
39775   arg5 = *argp5;
39776   {
39777     try {
39778       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39779     } catch (std::out_of_range& e) {
39780       {
39781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39782       };
39783     } catch (std::exception& e) {
39784       {
39785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39786       };
39787     } catch (...) {
39788       {
39789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39790       };
39791     }
39792   }
39793 }
39794
39795
39796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39797   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39798   SwigValueWrapper< Dali::Property > arg2 ;
39799   Dali::KeyFrames *arg3 = 0 ;
39800   Dali::Property *argp2 ;
39801
39802   arg1 = (Dali::Animation *)jarg1;
39803   argp2 = (Dali::Property *)jarg2;
39804   if (!argp2) {
39805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39806     return ;
39807   }
39808   arg2 = *argp2;
39809   arg3 = (Dali::KeyFrames *)jarg3;
39810   if (!arg3) {
39811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39812     return ;
39813   }
39814   {
39815     try {
39816       (arg1)->AnimateBetween(arg2,*arg3);
39817     } catch (std::out_of_range& e) {
39818       {
39819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39820       };
39821     } catch (std::exception& e) {
39822       {
39823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39824       };
39825     } catch (...) {
39826       {
39827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39828       };
39829     }
39830   }
39831 }
39832
39833
39834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39835   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39836   SwigValueWrapper< Dali::Property > arg2 ;
39837   Dali::KeyFrames *arg3 = 0 ;
39838   Dali::Animation::Interpolation arg4 ;
39839   Dali::Property *argp2 ;
39840
39841   arg1 = (Dali::Animation *)jarg1;
39842   argp2 = (Dali::Property *)jarg2;
39843   if (!argp2) {
39844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39845     return ;
39846   }
39847   arg2 = *argp2;
39848   arg3 = (Dali::KeyFrames *)jarg3;
39849   if (!arg3) {
39850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39851     return ;
39852   }
39853   arg4 = (Dali::Animation::Interpolation)jarg4;
39854   {
39855     try {
39856       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39857     } catch (std::out_of_range& e) {
39858       {
39859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39860       };
39861     } catch (std::exception& e) {
39862       {
39863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39864       };
39865     } catch (...) {
39866       {
39867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39868       };
39869     }
39870   }
39871 }
39872
39873
39874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39875   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39876   SwigValueWrapper< Dali::Property > arg2 ;
39877   Dali::KeyFrames *arg3 = 0 ;
39878   Dali::AlphaFunction arg4 ;
39879   Dali::Property *argp2 ;
39880   Dali::AlphaFunction *argp4 ;
39881
39882   arg1 = (Dali::Animation *)jarg1;
39883   argp2 = (Dali::Property *)jarg2;
39884   if (!argp2) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39886     return ;
39887   }
39888   arg2 = *argp2;
39889   arg3 = (Dali::KeyFrames *)jarg3;
39890   if (!arg3) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39892     return ;
39893   }
39894   argp4 = (Dali::AlphaFunction *)jarg4;
39895   if (!argp4) {
39896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39897     return ;
39898   }
39899   arg4 = *argp4;
39900   {
39901     try {
39902       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39903     } catch (std::out_of_range& e) {
39904       {
39905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39906       };
39907     } catch (std::exception& e) {
39908       {
39909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39910       };
39911     } catch (...) {
39912       {
39913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39914       };
39915     }
39916   }
39917 }
39918
39919
39920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39921   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39922   SwigValueWrapper< Dali::Property > arg2 ;
39923   Dali::KeyFrames *arg3 = 0 ;
39924   Dali::AlphaFunction arg4 ;
39925   Dali::Animation::Interpolation arg5 ;
39926   Dali::Property *argp2 ;
39927   Dali::AlphaFunction *argp4 ;
39928
39929   arg1 = (Dali::Animation *)jarg1;
39930   argp2 = (Dali::Property *)jarg2;
39931   if (!argp2) {
39932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39933     return ;
39934   }
39935   arg2 = *argp2;
39936   arg3 = (Dali::KeyFrames *)jarg3;
39937   if (!arg3) {
39938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39939     return ;
39940   }
39941   argp4 = (Dali::AlphaFunction *)jarg4;
39942   if (!argp4) {
39943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39944     return ;
39945   }
39946   arg4 = *argp4;
39947   arg5 = (Dali::Animation::Interpolation)jarg5;
39948   {
39949     try {
39950       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39951     } catch (std::out_of_range& e) {
39952       {
39953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39954       };
39955     } catch (std::exception& e) {
39956       {
39957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39958       };
39959     } catch (...) {
39960       {
39961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39962       };
39963     }
39964   }
39965 }
39966
39967
39968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39969   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39970   SwigValueWrapper< Dali::Property > arg2 ;
39971   Dali::KeyFrames *arg3 = 0 ;
39972   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39973   Dali::Property *argp2 ;
39974   Dali::TimePeriod *argp4 ;
39975
39976   arg1 = (Dali::Animation *)jarg1;
39977   argp2 = (Dali::Property *)jarg2;
39978   if (!argp2) {
39979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39980     return ;
39981   }
39982   arg2 = *argp2;
39983   arg3 = (Dali::KeyFrames *)jarg3;
39984   if (!arg3) {
39985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39986     return ;
39987   }
39988   argp4 = (Dali::TimePeriod *)jarg4;
39989   if (!argp4) {
39990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39991     return ;
39992   }
39993   arg4 = *argp4;
39994   {
39995     try {
39996       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39997     } catch (std::out_of_range& e) {
39998       {
39999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40000       };
40001     } catch (std::exception& e) {
40002       {
40003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40008       };
40009     }
40010   }
40011 }
40012
40013
40014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40015   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40016   SwigValueWrapper< Dali::Property > arg2 ;
40017   Dali::KeyFrames *arg3 = 0 ;
40018   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40019   Dali::Animation::Interpolation arg5 ;
40020   Dali::Property *argp2 ;
40021   Dali::TimePeriod *argp4 ;
40022
40023   arg1 = (Dali::Animation *)jarg1;
40024   argp2 = (Dali::Property *)jarg2;
40025   if (!argp2) {
40026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40027     return ;
40028   }
40029   arg2 = *argp2;
40030   arg3 = (Dali::KeyFrames *)jarg3;
40031   if (!arg3) {
40032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40033     return ;
40034   }
40035   argp4 = (Dali::TimePeriod *)jarg4;
40036   if (!argp4) {
40037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40038     return ;
40039   }
40040   arg4 = *argp4;
40041   arg5 = (Dali::Animation::Interpolation)jarg5;
40042   {
40043     try {
40044       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40045     } catch (std::out_of_range& e) {
40046       {
40047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40048       };
40049     } catch (std::exception& e) {
40050       {
40051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40052       };
40053     } catch (...) {
40054       {
40055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40056       };
40057     }
40058   }
40059 }
40060
40061
40062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40063   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40064   SwigValueWrapper< Dali::Property > arg2 ;
40065   Dali::KeyFrames *arg3 = 0 ;
40066   Dali::AlphaFunction arg4 ;
40067   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40068   Dali::Property *argp2 ;
40069   Dali::AlphaFunction *argp4 ;
40070   Dali::TimePeriod *argp5 ;
40071
40072   arg1 = (Dali::Animation *)jarg1;
40073   argp2 = (Dali::Property *)jarg2;
40074   if (!argp2) {
40075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40076     return ;
40077   }
40078   arg2 = *argp2;
40079   arg3 = (Dali::KeyFrames *)jarg3;
40080   if (!arg3) {
40081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40082     return ;
40083   }
40084   argp4 = (Dali::AlphaFunction *)jarg4;
40085   if (!argp4) {
40086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40087     return ;
40088   }
40089   arg4 = *argp4;
40090   argp5 = (Dali::TimePeriod *)jarg5;
40091   if (!argp5) {
40092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40093     return ;
40094   }
40095   arg5 = *argp5;
40096   {
40097     try {
40098       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40099     } catch (std::out_of_range& e) {
40100       {
40101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40102       };
40103     } catch (std::exception& e) {
40104       {
40105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40106       };
40107     } catch (...) {
40108       {
40109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40110       };
40111     }
40112   }
40113 }
40114
40115
40116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40117   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40118   SwigValueWrapper< Dali::Property > arg2 ;
40119   Dali::KeyFrames *arg3 = 0 ;
40120   Dali::AlphaFunction arg4 ;
40121   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40122   Dali::Animation::Interpolation arg6 ;
40123   Dali::Property *argp2 ;
40124   Dali::AlphaFunction *argp4 ;
40125   Dali::TimePeriod *argp5 ;
40126
40127   arg1 = (Dali::Animation *)jarg1;
40128   argp2 = (Dali::Property *)jarg2;
40129   if (!argp2) {
40130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40131     return ;
40132   }
40133   arg2 = *argp2;
40134   arg3 = (Dali::KeyFrames *)jarg3;
40135   if (!arg3) {
40136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40137     return ;
40138   }
40139   argp4 = (Dali::AlphaFunction *)jarg4;
40140   if (!argp4) {
40141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40142     return ;
40143   }
40144   arg4 = *argp4;
40145   argp5 = (Dali::TimePeriod *)jarg5;
40146   if (!argp5) {
40147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40148     return ;
40149   }
40150   arg5 = *argp5;
40151   arg6 = (Dali::Animation::Interpolation)jarg6;
40152   {
40153     try {
40154       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40155     } catch (std::out_of_range& e) {
40156       {
40157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40158       };
40159     } catch (std::exception& e) {
40160       {
40161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40162       };
40163     } catch (...) {
40164       {
40165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40166       };
40167     }
40168   }
40169 }
40170
40171
40172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40173   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40174   Dali::Actor arg2 ;
40175   Dali::Path arg3 ;
40176   Dali::Vector3 *arg4 = 0 ;
40177   Dali::Actor *argp2 ;
40178   Dali::Path *argp3 ;
40179
40180   arg1 = (Dali::Animation *)jarg1;
40181   argp2 = (Dali::Actor *)jarg2;
40182   if (!argp2) {
40183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40184     return ;
40185   }
40186   arg2 = *argp2;
40187   argp3 = (Dali::Path *)jarg3;
40188   if (!argp3) {
40189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40190     return ;
40191   }
40192   arg3 = *argp3;
40193   arg4 = (Dali::Vector3 *)jarg4;
40194   if (!arg4) {
40195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40196     return ;
40197   }
40198   {
40199     try {
40200       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40201     } catch (std::out_of_range& e) {
40202       {
40203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40204       };
40205     } catch (std::exception& e) {
40206       {
40207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40208       };
40209     } catch (...) {
40210       {
40211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40212       };
40213     }
40214   }
40215 }
40216
40217
40218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40219   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40220   Dali::Actor arg2 ;
40221   Dali::Path arg3 ;
40222   Dali::Vector3 *arg4 = 0 ;
40223   Dali::AlphaFunction arg5 ;
40224   Dali::Actor *argp2 ;
40225   Dali::Path *argp3 ;
40226   Dali::AlphaFunction *argp5 ;
40227
40228   arg1 = (Dali::Animation *)jarg1;
40229   argp2 = (Dali::Actor *)jarg2;
40230   if (!argp2) {
40231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40232     return ;
40233   }
40234   arg2 = *argp2;
40235   argp3 = (Dali::Path *)jarg3;
40236   if (!argp3) {
40237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40238     return ;
40239   }
40240   arg3 = *argp3;
40241   arg4 = (Dali::Vector3 *)jarg4;
40242   if (!arg4) {
40243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40244     return ;
40245   }
40246   argp5 = (Dali::AlphaFunction *)jarg5;
40247   if (!argp5) {
40248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40249     return ;
40250   }
40251   arg5 = *argp5;
40252   {
40253     try {
40254       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40255     } catch (std::out_of_range& e) {
40256       {
40257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40258       };
40259     } catch (std::exception& e) {
40260       {
40261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40262       };
40263     } catch (...) {
40264       {
40265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40266       };
40267     }
40268   }
40269 }
40270
40271
40272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40273   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40274   Dali::Actor arg2 ;
40275   Dali::Path arg3 ;
40276   Dali::Vector3 *arg4 = 0 ;
40277   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40278   Dali::Actor *argp2 ;
40279   Dali::Path *argp3 ;
40280   Dali::TimePeriod *argp5 ;
40281
40282   arg1 = (Dali::Animation *)jarg1;
40283   argp2 = (Dali::Actor *)jarg2;
40284   if (!argp2) {
40285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40286     return ;
40287   }
40288   arg2 = *argp2;
40289   argp3 = (Dali::Path *)jarg3;
40290   if (!argp3) {
40291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40292     return ;
40293   }
40294   arg3 = *argp3;
40295   arg4 = (Dali::Vector3 *)jarg4;
40296   if (!arg4) {
40297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40298     return ;
40299   }
40300   argp5 = (Dali::TimePeriod *)jarg5;
40301   if (!argp5) {
40302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40303     return ;
40304   }
40305   arg5 = *argp5;
40306   {
40307     try {
40308       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40309     } catch (std::out_of_range& e) {
40310       {
40311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40312       };
40313     } catch (std::exception& e) {
40314       {
40315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40316       };
40317     } catch (...) {
40318       {
40319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40320       };
40321     }
40322   }
40323 }
40324
40325
40326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40327   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40328   Dali::Actor arg2 ;
40329   Dali::Path arg3 ;
40330   Dali::Vector3 *arg4 = 0 ;
40331   Dali::AlphaFunction arg5 ;
40332   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40333   Dali::Actor *argp2 ;
40334   Dali::Path *argp3 ;
40335   Dali::AlphaFunction *argp5 ;
40336   Dali::TimePeriod *argp6 ;
40337
40338   arg1 = (Dali::Animation *)jarg1;
40339   argp2 = (Dali::Actor *)jarg2;
40340   if (!argp2) {
40341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40342     return ;
40343   }
40344   arg2 = *argp2;
40345   argp3 = (Dali::Path *)jarg3;
40346   if (!argp3) {
40347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40348     return ;
40349   }
40350   arg3 = *argp3;
40351   arg4 = (Dali::Vector3 *)jarg4;
40352   if (!arg4) {
40353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40354     return ;
40355   }
40356   argp5 = (Dali::AlphaFunction *)jarg5;
40357   if (!argp5) {
40358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40359     return ;
40360   }
40361   arg5 = *argp5;
40362   argp6 = (Dali::TimePeriod *)jarg6;
40363   if (!argp6) {
40364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40365     return ;
40366   }
40367   arg6 = *argp6;
40368   {
40369     try {
40370       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40371     } catch (std::out_of_range& e) {
40372       {
40373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40374       };
40375     } catch (std::exception& e) {
40376       {
40377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40378       };
40379     } catch (...) {
40380       {
40381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40382       };
40383     }
40384   }
40385 }
40386
40387
40388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40389   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40390   Dali::Actor arg2 ;
40391   float arg3 ;
40392   Dali::Actor *argp2 ;
40393
40394   arg1 = (Dali::Animation *)jarg1;
40395   argp2 = (Dali::Actor *)jarg2;
40396   if (!argp2) {
40397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40398     return ;
40399   }
40400   arg2 = *argp2;
40401   arg3 = (float)jarg3;
40402   {
40403     try {
40404       (arg1)->Show(arg2,arg3);
40405     } catch (std::out_of_range& e) {
40406       {
40407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40408       };
40409     } catch (std::exception& e) {
40410       {
40411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40412       };
40413     } catch (...) {
40414       {
40415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40416       };
40417     }
40418   }
40419 }
40420
40421
40422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40423   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40424   Dali::Actor arg2 ;
40425   float arg3 ;
40426   Dali::Actor *argp2 ;
40427
40428   arg1 = (Dali::Animation *)jarg1;
40429   argp2 = (Dali::Actor *)jarg2;
40430   if (!argp2) {
40431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40432     return ;
40433   }
40434   arg2 = *argp2;
40435   arg3 = (float)jarg3;
40436   {
40437     try {
40438       (arg1)->Hide(arg2,arg3);
40439     } catch (std::out_of_range& e) {
40440       {
40441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40442       };
40443     } catch (std::exception& e) {
40444       {
40445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40446       };
40447     } catch (...) {
40448       {
40449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40450       };
40451     }
40452   }
40453 }
40454
40455
40456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40457   int jresult ;
40458   int result;
40459
40460   result = (int)Dali::LinearConstrainer::Property::VALUE;
40461   jresult = (int)result;
40462   return jresult;
40463 }
40464
40465
40466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40467   int jresult ;
40468   int result;
40469
40470   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40471   jresult = (int)result;
40472   return jresult;
40473 }
40474
40475
40476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40477   void * jresult ;
40478   Dali::LinearConstrainer::Property *result = 0 ;
40479
40480   {
40481     try {
40482       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40483     } catch (std::out_of_range& e) {
40484       {
40485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40486       };
40487     } catch (std::exception& e) {
40488       {
40489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40490       };
40491     } catch (...) {
40492       {
40493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40494       };
40495     }
40496   }
40497   jresult = (void *)result;
40498   return jresult;
40499 }
40500
40501
40502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40503   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40504
40505   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40506   {
40507     try {
40508       delete arg1;
40509     } catch (std::out_of_range& e) {
40510       {
40511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40512       };
40513     } catch (std::exception& e) {
40514       {
40515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40516       };
40517     } catch (...) {
40518       {
40519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40520       };
40521     }
40522   }
40523 }
40524
40525
40526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40527   void * jresult ;
40528   Dali::LinearConstrainer result;
40529
40530   {
40531     try {
40532       result = Dali::LinearConstrainer::New();
40533     } catch (std::out_of_range& e) {
40534       {
40535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40536       };
40537     } catch (std::exception& e) {
40538       {
40539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40540       };
40541     } catch (...) {
40542       {
40543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40544       };
40545     }
40546   }
40547   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40548   return jresult;
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40553   void * jresult ;
40554   Dali::BaseHandle arg1 ;
40555   Dali::BaseHandle *argp1 ;
40556   Dali::LinearConstrainer result;
40557
40558   argp1 = (Dali::BaseHandle *)jarg1;
40559   if (!argp1) {
40560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40561     return 0;
40562   }
40563   arg1 = *argp1;
40564   {
40565     try {
40566       result = Dali::LinearConstrainer::DownCast(arg1);
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40582   return jresult;
40583 }
40584
40585
40586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40587   void * jresult ;
40588   Dali::LinearConstrainer *result = 0 ;
40589
40590   {
40591     try {
40592       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40593     } catch (std::out_of_range& e) {
40594       {
40595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (std::exception& e) {
40598       {
40599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40600       };
40601     } catch (...) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40604       };
40605     }
40606   }
40607   jresult = (void *)result;
40608   return jresult;
40609 }
40610
40611
40612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40613   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40614
40615   arg1 = (Dali::LinearConstrainer *)jarg1;
40616   {
40617     try {
40618       delete arg1;
40619     } catch (std::out_of_range& e) {
40620       {
40621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40622       };
40623     } catch (std::exception& e) {
40624       {
40625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40626       };
40627     } catch (...) {
40628       {
40629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40630       };
40631     }
40632   }
40633 }
40634
40635
40636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40637   void * jresult ;
40638   Dali::LinearConstrainer *arg1 = 0 ;
40639   Dali::LinearConstrainer *result = 0 ;
40640
40641   arg1 = (Dali::LinearConstrainer *)jarg1;
40642   if (!arg1) {
40643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40644     return 0;
40645   }
40646   {
40647     try {
40648       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40649     } catch (std::out_of_range& e) {
40650       {
40651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (std::exception& e) {
40654       {
40655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40656       };
40657     } catch (...) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40660       };
40661     }
40662   }
40663   jresult = (void *)result;
40664   return jresult;
40665 }
40666
40667
40668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40669   void * jresult ;
40670   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40671   Dali::LinearConstrainer *arg2 = 0 ;
40672   Dali::LinearConstrainer *result = 0 ;
40673
40674   arg1 = (Dali::LinearConstrainer *)jarg1;
40675   arg2 = (Dali::LinearConstrainer *)jarg2;
40676   if (!arg2) {
40677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40678     return 0;
40679   }
40680   {
40681     try {
40682       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40683     } catch (std::out_of_range& e) {
40684       {
40685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40686       };
40687     } catch (std::exception& e) {
40688       {
40689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40690       };
40691     } catch (...) {
40692       {
40693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40694       };
40695     }
40696   }
40697   jresult = (void *)result;
40698   return jresult;
40699 }
40700
40701
40702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40703   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40704   SwigValueWrapper< Dali::Property > arg2 ;
40705   SwigValueWrapper< Dali::Property > arg3 ;
40706   Dali::Vector2 *arg4 = 0 ;
40707   Dali::Vector2 *arg5 = 0 ;
40708   Dali::Property *argp2 ;
40709   Dali::Property *argp3 ;
40710
40711   arg1 = (Dali::LinearConstrainer *)jarg1;
40712   argp2 = (Dali::Property *)jarg2;
40713   if (!argp2) {
40714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40715     return ;
40716   }
40717   arg2 = *argp2;
40718   argp3 = (Dali::Property *)jarg3;
40719   if (!argp3) {
40720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40721     return ;
40722   }
40723   arg3 = *argp3;
40724   arg4 = (Dali::Vector2 *)jarg4;
40725   if (!arg4) {
40726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40727     return ;
40728   }
40729   arg5 = (Dali::Vector2 *)jarg5;
40730   if (!arg5) {
40731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40732     return ;
40733   }
40734   {
40735     try {
40736       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40737     } catch (std::out_of_range& e) {
40738       {
40739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40740       };
40741     } catch (std::exception& e) {
40742       {
40743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40744       };
40745     } catch (...) {
40746       {
40747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40748       };
40749     }
40750   }
40751 }
40752
40753
40754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40755   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40756   SwigValueWrapper< Dali::Property > arg2 ;
40757   SwigValueWrapper< Dali::Property > arg3 ;
40758   Dali::Vector2 *arg4 = 0 ;
40759   Dali::Property *argp2 ;
40760   Dali::Property *argp3 ;
40761
40762   arg1 = (Dali::LinearConstrainer *)jarg1;
40763   argp2 = (Dali::Property *)jarg2;
40764   if (!argp2) {
40765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40766     return ;
40767   }
40768   arg2 = *argp2;
40769   argp3 = (Dali::Property *)jarg3;
40770   if (!argp3) {
40771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40772     return ;
40773   }
40774   arg3 = *argp3;
40775   arg4 = (Dali::Vector2 *)jarg4;
40776   if (!arg4) {
40777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40778     return ;
40779   }
40780   {
40781     try {
40782       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40783     } catch (std::out_of_range& e) {
40784       {
40785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40786       };
40787     } catch (std::exception& e) {
40788       {
40789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40790       };
40791     } catch (...) {
40792       {
40793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40794       };
40795     }
40796   }
40797 }
40798
40799
40800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40801   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40802   Dali::Handle *arg2 = 0 ;
40803
40804   arg1 = (Dali::LinearConstrainer *)jarg1;
40805   arg2 = (Dali::Handle *)jarg2;
40806   if (!arg2) {
40807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40808     return ;
40809   }
40810   {
40811     try {
40812       (arg1)->Remove(*arg2);
40813     } catch (std::out_of_range& e) {
40814       {
40815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40816       };
40817     } catch (std::exception& e) {
40818       {
40819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40820       };
40821     } catch (...) {
40822       {
40823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40824       };
40825     }
40826   }
40827 }
40828
40829
40830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40831   int jresult ;
40832   int result;
40833
40834   result = (int)Dali::PathConstrainer::Property::FORWARD;
40835   jresult = (int)result;
40836   return jresult;
40837 }
40838
40839
40840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40841   int jresult ;
40842   int result;
40843
40844   result = (int)Dali::PathConstrainer::Property::POINTS;
40845   jresult = (int)result;
40846   return jresult;
40847 }
40848
40849
40850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40851   int jresult ;
40852   int result;
40853
40854   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40855   jresult = (int)result;
40856   return jresult;
40857 }
40858
40859
40860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40861   void * jresult ;
40862   Dali::PathConstrainer::Property *result = 0 ;
40863
40864   {
40865     try {
40866       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40867     } catch (std::out_of_range& e) {
40868       {
40869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40870       };
40871     } catch (std::exception& e) {
40872       {
40873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40874       };
40875     } catch (...) {
40876       {
40877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40878       };
40879     }
40880   }
40881   jresult = (void *)result;
40882   return jresult;
40883 }
40884
40885
40886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40887   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40888
40889   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40890   {
40891     try {
40892       delete arg1;
40893     } catch (std::out_of_range& e) {
40894       {
40895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (std::exception& e) {
40898       {
40899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40904       };
40905     }
40906   }
40907 }
40908
40909
40910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40911   void * jresult ;
40912   Dali::PathConstrainer result;
40913
40914   {
40915     try {
40916       result = Dali::PathConstrainer::New();
40917     } catch (std::out_of_range& e) {
40918       {
40919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40920       };
40921     } catch (std::exception& e) {
40922       {
40923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40924       };
40925     } catch (...) {
40926       {
40927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40928       };
40929     }
40930   }
40931   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40932   return jresult;
40933 }
40934
40935
40936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40937   void * jresult ;
40938   Dali::BaseHandle arg1 ;
40939   Dali::BaseHandle *argp1 ;
40940   Dali::PathConstrainer result;
40941
40942   argp1 = (Dali::BaseHandle *)jarg1;
40943   if (!argp1) {
40944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40945     return 0;
40946   }
40947   arg1 = *argp1;
40948   {
40949     try {
40950       result = Dali::PathConstrainer::DownCast(arg1);
40951     } catch (std::out_of_range& e) {
40952       {
40953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (std::exception& e) {
40956       {
40957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40958       };
40959     } catch (...) {
40960       {
40961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40962       };
40963     }
40964   }
40965   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40966   return jresult;
40967 }
40968
40969
40970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40971   void * jresult ;
40972   Dali::PathConstrainer *result = 0 ;
40973
40974   {
40975     try {
40976       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40977     } catch (std::out_of_range& e) {
40978       {
40979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40980       };
40981     } catch (std::exception& e) {
40982       {
40983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40984       };
40985     } catch (...) {
40986       {
40987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40988       };
40989     }
40990   }
40991   jresult = (void *)result;
40992   return jresult;
40993 }
40994
40995
40996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40997   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40998
40999   arg1 = (Dali::PathConstrainer *)jarg1;
41000   {
41001     try {
41002       delete arg1;
41003     } catch (std::out_of_range& e) {
41004       {
41005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41006       };
41007     } catch (std::exception& e) {
41008       {
41009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41010       };
41011     } catch (...) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41014       };
41015     }
41016   }
41017 }
41018
41019
41020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41021   void * jresult ;
41022   Dali::PathConstrainer *arg1 = 0 ;
41023   Dali::PathConstrainer *result = 0 ;
41024
41025   arg1 = (Dali::PathConstrainer *)jarg1;
41026   if (!arg1) {
41027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41028     return 0;
41029   }
41030   {
41031     try {
41032       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41033     } catch (std::out_of_range& e) {
41034       {
41035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41036       };
41037     } catch (std::exception& e) {
41038       {
41039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41040       };
41041     } catch (...) {
41042       {
41043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41044       };
41045     }
41046   }
41047   jresult = (void *)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41053   void * jresult ;
41054   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41055   Dali::PathConstrainer *arg2 = 0 ;
41056   Dali::PathConstrainer *result = 0 ;
41057
41058   arg1 = (Dali::PathConstrainer *)jarg1;
41059   arg2 = (Dali::PathConstrainer *)jarg2;
41060   if (!arg2) {
41061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41062     return 0;
41063   }
41064   {
41065     try {
41066       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41067     } catch (std::out_of_range& e) {
41068       {
41069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (std::exception& e) {
41072       {
41073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41074       };
41075     } catch (...) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41078       };
41079     }
41080   }
41081   jresult = (void *)result;
41082   return jresult;
41083 }
41084
41085
41086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41087   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41088   SwigValueWrapper< Dali::Property > arg2 ;
41089   SwigValueWrapper< Dali::Property > arg3 ;
41090   Dali::Vector2 *arg4 = 0 ;
41091   Dali::Vector2 *arg5 = 0 ;
41092   Dali::Property *argp2 ;
41093   Dali::Property *argp3 ;
41094
41095   arg1 = (Dali::PathConstrainer *)jarg1;
41096   argp2 = (Dali::Property *)jarg2;
41097   if (!argp2) {
41098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41099     return ;
41100   }
41101   arg2 = *argp2;
41102   argp3 = (Dali::Property *)jarg3;
41103   if (!argp3) {
41104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41105     return ;
41106   }
41107   arg3 = *argp3;
41108   arg4 = (Dali::Vector2 *)jarg4;
41109   if (!arg4) {
41110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41111     return ;
41112   }
41113   arg5 = (Dali::Vector2 *)jarg5;
41114   if (!arg5) {
41115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41116     return ;
41117   }
41118   {
41119     try {
41120       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41121     } catch (std::out_of_range& e) {
41122       {
41123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41124       };
41125     } catch (std::exception& e) {
41126       {
41127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41128       };
41129     } catch (...) {
41130       {
41131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41132       };
41133     }
41134   }
41135 }
41136
41137
41138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41139   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41140   SwigValueWrapper< Dali::Property > arg2 ;
41141   SwigValueWrapper< Dali::Property > arg3 ;
41142   Dali::Vector2 *arg4 = 0 ;
41143   Dali::Property *argp2 ;
41144   Dali::Property *argp3 ;
41145
41146   arg1 = (Dali::PathConstrainer *)jarg1;
41147   argp2 = (Dali::Property *)jarg2;
41148   if (!argp2) {
41149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41150     return ;
41151   }
41152   arg2 = *argp2;
41153   argp3 = (Dali::Property *)jarg3;
41154   if (!argp3) {
41155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41156     return ;
41157   }
41158   arg3 = *argp3;
41159   arg4 = (Dali::Vector2 *)jarg4;
41160   if (!arg4) {
41161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41162     return ;
41163   }
41164   {
41165     try {
41166       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41167     } catch (std::out_of_range& e) {
41168       {
41169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41170       };
41171     } catch (std::exception& e) {
41172       {
41173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41174       };
41175     } catch (...) {
41176       {
41177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41178       };
41179     }
41180   }
41181 }
41182
41183
41184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41185   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41186   Dali::Handle *arg2 = 0 ;
41187
41188   arg1 = (Dali::PathConstrainer *)jarg1;
41189   arg2 = (Dali::Handle *)jarg2;
41190   if (!arg2) {
41191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41192     return ;
41193   }
41194   {
41195     try {
41196       (arg1)->Remove(*arg2);
41197     } catch (std::out_of_range& e) {
41198       {
41199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41200       };
41201     } catch (std::exception& e) {
41202       {
41203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41204       };
41205     } catch (...) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41208       };
41209     }
41210   }
41211 }
41212
41213
41214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41215   int jresult ;
41216   Dali::FittingMode::Type result;
41217
41218   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41219   jresult = (int)result;
41220   return jresult;
41221 }
41222
41223
41224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41225   int jresult ;
41226   Dali::SamplingMode::Type result;
41227
41228   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41229   jresult = (int)result;
41230   return jresult;
41231 }
41232
41233
41234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41235   void * jresult ;
41236   Dali::BufferImage *result = 0 ;
41237
41238   {
41239     try {
41240       result = (Dali::BufferImage *)new Dali::BufferImage();
41241     } catch (std::out_of_range& e) {
41242       {
41243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41244       };
41245     } catch (std::exception& e) {
41246       {
41247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41248       };
41249     } catch (...) {
41250       {
41251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41252       };
41253     }
41254   }
41255   jresult = (void *)result;
41256   return jresult;
41257 }
41258
41259
41260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41261   void * jresult ;
41262   unsigned int arg1 ;
41263   unsigned int arg2 ;
41264   Dali::Pixel::Format arg3 ;
41265   Dali::BufferImage result;
41266
41267   arg1 = (unsigned int)jarg1;
41268   arg2 = (unsigned int)jarg2;
41269   arg3 = (Dali::Pixel::Format)jarg3;
41270   {
41271     try {
41272       result = Dali::BufferImage::New(arg1,arg2,arg3);
41273     } catch (std::out_of_range& e) {
41274       {
41275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41276       };
41277     } catch (std::exception& e) {
41278       {
41279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41280       };
41281     } catch (...) {
41282       {
41283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41284       };
41285     }
41286   }
41287   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41288   return jresult;
41289 }
41290
41291
41292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41293   void * jresult ;
41294   unsigned int arg1 ;
41295   unsigned int arg2 ;
41296   Dali::BufferImage result;
41297
41298   arg1 = (unsigned int)jarg1;
41299   arg2 = (unsigned int)jarg2;
41300   {
41301     try {
41302       result = Dali::BufferImage::New(arg1,arg2);
41303     } catch (std::out_of_range& e) {
41304       {
41305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (std::exception& e) {
41308       {
41309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41310       };
41311     } catch (...) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41314       };
41315     }
41316   }
41317   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41318   return jresult;
41319 }
41320
41321
41322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41323   void * jresult ;
41324   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41325   unsigned int arg2 ;
41326   unsigned int arg3 ;
41327   Dali::Pixel::Format arg4 ;
41328   unsigned int arg5 ;
41329   Dali::BufferImage result;
41330
41331   arg1 = jarg1;
41332   arg2 = (unsigned int)jarg2;
41333   arg3 = (unsigned int)jarg3;
41334   arg4 = (Dali::Pixel::Format)jarg4;
41335   arg5 = (unsigned int)jarg5;
41336   {
41337     try {
41338       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41339     } catch (std::out_of_range& e) {
41340       {
41341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (std::exception& e) {
41344       {
41345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41346       };
41347     } catch (...) {
41348       {
41349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41350       };
41351     }
41352   }
41353   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41354
41355
41356   return jresult;
41357 }
41358
41359
41360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41361   void * jresult ;
41362   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41363   unsigned int arg2 ;
41364   unsigned int arg3 ;
41365   Dali::Pixel::Format arg4 ;
41366   Dali::BufferImage result;
41367
41368   arg1 = jarg1;
41369   arg2 = (unsigned int)jarg2;
41370   arg3 = (unsigned int)jarg3;
41371   arg4 = (Dali::Pixel::Format)jarg4;
41372   {
41373     try {
41374       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41375     } catch (std::out_of_range& e) {
41376       {
41377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41378       };
41379     } catch (std::exception& e) {
41380       {
41381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41382       };
41383     } catch (...) {
41384       {
41385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41386       };
41387     }
41388   }
41389   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41390
41391
41392   return jresult;
41393 }
41394
41395
41396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41397   void * jresult ;
41398   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41399   unsigned int arg2 ;
41400   unsigned int arg3 ;
41401   Dali::BufferImage result;
41402
41403   arg1 = jarg1;
41404   arg2 = (unsigned int)jarg2;
41405   arg3 = (unsigned int)jarg3;
41406   {
41407     try {
41408       result = Dali::BufferImage::New(arg1,arg2,arg3);
41409     } catch (std::out_of_range& e) {
41410       {
41411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41412       };
41413     } catch (std::exception& e) {
41414       {
41415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41416       };
41417     } catch (...) {
41418       {
41419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41420       };
41421     }
41422   }
41423   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41424
41425
41426   return jresult;
41427 }
41428
41429
41430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41431   void * jresult ;
41432   Dali::BaseHandle arg1 ;
41433   Dali::BaseHandle *argp1 ;
41434   Dali::BufferImage result;
41435
41436   argp1 = (Dali::BaseHandle *)jarg1;
41437   if (!argp1) {
41438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41439     return 0;
41440   }
41441   arg1 = *argp1;
41442   {
41443     try {
41444       result = Dali::BufferImage::DownCast(arg1);
41445     } catch (std::out_of_range& e) {
41446       {
41447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41448       };
41449     } catch (std::exception& e) {
41450       {
41451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41452       };
41453     } catch (...) {
41454       {
41455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41456       };
41457     }
41458   }
41459   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41460   return jresult;
41461 }
41462
41463
41464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41465   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41466
41467   arg1 = (Dali::BufferImage *)jarg1;
41468   {
41469     try {
41470       delete arg1;
41471     } catch (std::out_of_range& e) {
41472       {
41473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41474       };
41475     } catch (std::exception& e) {
41476       {
41477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41478       };
41479     } catch (...) {
41480       {
41481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41482       };
41483     }
41484   }
41485 }
41486
41487
41488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41489   void * jresult ;
41490   Dali::BufferImage *arg1 = 0 ;
41491   Dali::BufferImage *result = 0 ;
41492
41493   arg1 = (Dali::BufferImage *)jarg1;
41494   if (!arg1) {
41495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41496     return 0;
41497   }
41498   {
41499     try {
41500       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41501     } catch (std::out_of_range& e) {
41502       {
41503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41504       };
41505     } catch (std::exception& e) {
41506       {
41507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41508       };
41509     } catch (...) {
41510       {
41511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41512       };
41513     }
41514   }
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41521   void * jresult ;
41522   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41523   Dali::BufferImage *arg2 = 0 ;
41524   Dali::BufferImage *result = 0 ;
41525
41526   arg1 = (Dali::BufferImage *)jarg1;
41527   arg2 = (Dali::BufferImage *)jarg2;
41528   if (!arg2) {
41529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41530     return 0;
41531   }
41532   {
41533     try {
41534       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41535     } catch (std::out_of_range& e) {
41536       {
41537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41538       };
41539     } catch (std::exception& e) {
41540       {
41541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41542       };
41543     } catch (...) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41546       };
41547     }
41548   }
41549   jresult = (void *)result;
41550   return jresult;
41551 }
41552
41553
41554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41555   void * jresult ;
41556   Dali::BufferImage result;
41557
41558   {
41559     try {
41560       result = Dali::BufferImage::WHITE();
41561     } catch (std::out_of_range& e) {
41562       {
41563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41564       };
41565     } catch (std::exception& e) {
41566       {
41567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41568       };
41569     } catch (...) {
41570       {
41571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41572       };
41573     }
41574   }
41575   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41576   return jresult;
41577 }
41578
41579
41580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41581   void * jresult ;
41582   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41583   Dali::PixelBuffer *result = 0 ;
41584
41585   arg1 = (Dali::BufferImage *)jarg1;
41586   {
41587     try {
41588       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41589     } catch (std::out_of_range& e) {
41590       {
41591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41592       };
41593     } catch (std::exception& e) {
41594       {
41595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41596       };
41597     } catch (...) {
41598       {
41599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41600       };
41601     }
41602   }
41603   jresult = (void *)result;
41604   return jresult;
41605 }
41606
41607
41608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41609   unsigned int jresult ;
41610   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41611   unsigned int result;
41612
41613   arg1 = (Dali::BufferImage *)jarg1;
41614   {
41615     try {
41616       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
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 (...) {
41626       {
41627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41628       };
41629     }
41630   }
41631   jresult = result;
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41637   unsigned int jresult ;
41638   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41639   unsigned int result;
41640
41641   arg1 = (Dali::BufferImage *)jarg1;
41642   {
41643     try {
41644       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41645     } catch (std::out_of_range& e) {
41646       {
41647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (std::exception& e) {
41650       {
41651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41652       };
41653     } catch (...) {
41654       {
41655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41656       };
41657     }
41658   }
41659   jresult = result;
41660   return jresult;
41661 }
41662
41663
41664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41665   int jresult ;
41666   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41667   Dali::Pixel::Format result;
41668
41669   arg1 = (Dali::BufferImage *)jarg1;
41670   {
41671     try {
41672       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41673     } catch (std::out_of_range& e) {
41674       {
41675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (std::exception& e) {
41678       {
41679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41680       };
41681     } catch (...) {
41682       {
41683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41684       };
41685     }
41686   }
41687   jresult = (int)result;
41688   return jresult;
41689 }
41690
41691
41692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41693   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41694
41695   arg1 = (Dali::BufferImage *)jarg1;
41696   {
41697     try {
41698       (arg1)->Update();
41699     } catch (std::out_of_range& e) {
41700       {
41701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41702       };
41703     } catch (std::exception& e) {
41704       {
41705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41706       };
41707     } catch (...) {
41708       {
41709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41710       };
41711     }
41712   }
41713 }
41714
41715
41716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41717   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41718   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41719   Dali::RectArea *argp2 ;
41720
41721   arg1 = (Dali::BufferImage *)jarg1;
41722   argp2 = (Dali::RectArea *)jarg2;
41723   if (!argp2) {
41724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41725     return ;
41726   }
41727   arg2 = *argp2;
41728   {
41729     try {
41730       (arg1)->Update(arg2);
41731     } catch (std::out_of_range& e) {
41732       {
41733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41734       };
41735     } catch (std::exception& e) {
41736       {
41737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41738       };
41739     } catch (...) {
41740       {
41741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41742       };
41743     }
41744   }
41745 }
41746
41747
41748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41749   unsigned int jresult ;
41750   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41751   bool result;
41752
41753   arg1 = (Dali::BufferImage *)jarg1;
41754   {
41755     try {
41756       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41757     } catch (std::out_of_range& e) {
41758       {
41759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (std::exception& e) {
41762       {
41763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771   jresult = result;
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41777   void * jresult ;
41778   Dali::EncodedBufferImage *result = 0 ;
41779
41780   {
41781     try {
41782       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (...) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41794       };
41795     }
41796   }
41797   jresult = (void *)result;
41798   return jresult;
41799 }
41800
41801
41802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41803   void * jresult ;
41804   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41805   std::size_t arg2 ;
41806   Dali::EncodedBufferImage result;
41807
41808   arg1 = (uint8_t *)jarg1;
41809   arg2 = (std::size_t)jarg2;
41810   {
41811     try {
41812       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41813     } catch (std::out_of_range& e) {
41814       {
41815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41816       };
41817     } catch (std::exception& e) {
41818       {
41819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41820       };
41821     } catch (...) {
41822       {
41823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41824       };
41825     }
41826   }
41827   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41828   return jresult;
41829 }
41830
41831
41832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41833   void * jresult ;
41834   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41835   std::size_t arg2 ;
41836   Dali::ImageDimensions arg3 ;
41837   Dali::FittingMode::Type arg4 ;
41838   Dali::SamplingMode::Type arg5 ;
41839   bool arg6 ;
41840   Dali::ImageDimensions *argp3 ;
41841   Dali::EncodedBufferImage result;
41842
41843   arg1 = (uint8_t *)jarg1;
41844   arg2 = (std::size_t)jarg2;
41845   argp3 = (Dali::ImageDimensions *)jarg3;
41846   if (!argp3) {
41847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41848     return 0;
41849   }
41850   arg3 = *argp3;
41851   arg4 = (Dali::FittingMode::Type)jarg4;
41852   arg5 = (Dali::SamplingMode::Type)jarg5;
41853   arg6 = jarg6 ? true : false;
41854   {
41855     try {
41856       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41857     } catch (std::out_of_range& e) {
41858       {
41859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41860       };
41861     } catch (std::exception& e) {
41862       {
41863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41864       };
41865     } catch (...) {
41866       {
41867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41868       };
41869     }
41870   }
41871   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41877   void * jresult ;
41878   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41879   std::size_t arg2 ;
41880   Dali::ImageDimensions arg3 ;
41881   Dali::FittingMode::Type arg4 ;
41882   Dali::SamplingMode::Type arg5 ;
41883   Dali::ImageDimensions *argp3 ;
41884   Dali::EncodedBufferImage result;
41885
41886   arg1 = (uint8_t *)jarg1;
41887   arg2 = (std::size_t)jarg2;
41888   argp3 = (Dali::ImageDimensions *)jarg3;
41889   if (!argp3) {
41890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41891     return 0;
41892   }
41893   arg3 = *argp3;
41894   arg4 = (Dali::FittingMode::Type)jarg4;
41895   arg5 = (Dali::SamplingMode::Type)jarg5;
41896   {
41897     try {
41898       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41899     } catch (std::out_of_range& e) {
41900       {
41901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (std::exception& e) {
41904       {
41905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41910       };
41911     }
41912   }
41913   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41914   return jresult;
41915 }
41916
41917
41918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41919   void * jresult ;
41920   Dali::BaseHandle arg1 ;
41921   Dali::BaseHandle *argp1 ;
41922   Dali::EncodedBufferImage result;
41923
41924   argp1 = (Dali::BaseHandle *)jarg1;
41925   if (!argp1) {
41926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41927     return 0;
41928   }
41929   arg1 = *argp1;
41930   {
41931     try {
41932       result = Dali::EncodedBufferImage::DownCast(arg1);
41933     } catch (std::out_of_range& e) {
41934       {
41935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41936       };
41937     } catch (std::exception& e) {
41938       {
41939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (...) {
41942       {
41943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41944       };
41945     }
41946   }
41947   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41948   return jresult;
41949 }
41950
41951
41952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41953   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41954
41955   arg1 = (Dali::EncodedBufferImage *)jarg1;
41956   {
41957     try {
41958       delete arg1;
41959     } catch (std::out_of_range& e) {
41960       {
41961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41962       };
41963     } catch (std::exception& e) {
41964       {
41965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41966       };
41967     } catch (...) {
41968       {
41969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41970       };
41971     }
41972   }
41973 }
41974
41975
41976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41977   void * jresult ;
41978   Dali::EncodedBufferImage *arg1 = 0 ;
41979   Dali::EncodedBufferImage *result = 0 ;
41980
41981   arg1 = (Dali::EncodedBufferImage *)jarg1;
41982   if (!arg1) {
41983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41984     return 0;
41985   }
41986   {
41987     try {
41988       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41989     } catch (std::out_of_range& e) {
41990       {
41991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (std::exception& e) {
41994       {
41995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41996       };
41997     } catch (...) {
41998       {
41999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42000       };
42001     }
42002   }
42003   jresult = (void *)result;
42004   return jresult;
42005 }
42006
42007
42008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42009   void * jresult ;
42010   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42011   Dali::EncodedBufferImage *arg2 = 0 ;
42012   Dali::EncodedBufferImage *result = 0 ;
42013
42014   arg1 = (Dali::EncodedBufferImage *)jarg1;
42015   arg2 = (Dali::EncodedBufferImage *)jarg2;
42016   if (!arg2) {
42017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42018     return 0;
42019   }
42020   {
42021     try {
42022       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42023     } catch (std::out_of_range& e) {
42024       {
42025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42026       };
42027     } catch (std::exception& e) {
42028       {
42029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42030       };
42031     } catch (...) {
42032       {
42033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42034       };
42035     }
42036   }
42037   jresult = (void *)result;
42038   return jresult;
42039 }
42040
42041
42042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42043   void * jresult ;
42044   Dali::NativeImage *result = 0 ;
42045
42046   {
42047     try {
42048       result = (Dali::NativeImage *)new Dali::NativeImage();
42049     } catch (std::out_of_range& e) {
42050       {
42051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (std::exception& e) {
42054       {
42055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42056       };
42057     } catch (...) {
42058       {
42059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42060       };
42061     }
42062   }
42063   jresult = (void *)result;
42064   return jresult;
42065 }
42066
42067
42068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42069   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42070
42071   arg1 = (Dali::NativeImage *)jarg1;
42072   {
42073     try {
42074       delete arg1;
42075     } catch (std::out_of_range& e) {
42076       {
42077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42078       };
42079     } catch (std::exception& e) {
42080       {
42081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42082       };
42083     } catch (...) {
42084       {
42085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42086       };
42087     }
42088   }
42089 }
42090
42091
42092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42093   void * jresult ;
42094   Dali::NativeImage *arg1 = 0 ;
42095   Dali::NativeImage *result = 0 ;
42096
42097   arg1 = (Dali::NativeImage *)jarg1;
42098   if (!arg1) {
42099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42100     return 0;
42101   }
42102   {
42103     try {
42104       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42105     } catch (std::out_of_range& e) {
42106       {
42107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42108       };
42109     } catch (std::exception& e) {
42110       {
42111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42112       };
42113     } catch (...) {
42114       {
42115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42116       };
42117     }
42118   }
42119   jresult = (void *)result;
42120   return jresult;
42121 }
42122
42123
42124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42125   void * jresult ;
42126   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42127   Dali::NativeImage *arg2 = 0 ;
42128   Dali::NativeImage *result = 0 ;
42129
42130   arg1 = (Dali::NativeImage *)jarg1;
42131   arg2 = (Dali::NativeImage *)jarg2;
42132   if (!arg2) {
42133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42134     return 0;
42135   }
42136   {
42137     try {
42138       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42139     } catch (std::out_of_range& e) {
42140       {
42141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42142       };
42143     } catch (std::exception& e) {
42144       {
42145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42146       };
42147     } catch (...) {
42148       {
42149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42150       };
42151     }
42152   }
42153   jresult = (void *)result;
42154   return jresult;
42155 }
42156
42157
42158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42159   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42160
42161   arg1 = (Dali::NativeImage *)jarg1;
42162   {
42163     try {
42164       (arg1)->CreateGlTexture();
42165     } catch (std::out_of_range& e) {
42166       {
42167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42168       };
42169     } catch (std::exception& e) {
42170       {
42171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42172       };
42173     } catch (...) {
42174       {
42175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42176       };
42177     }
42178   }
42179 }
42180
42181
42182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42183   void * jresult ;
42184   NativeImageInterface *arg1 = 0 ;
42185   Dali::NativeImage result;
42186
42187   arg1 = (NativeImageInterface *)jarg1;
42188   if (!arg1) {
42189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42190     return 0;
42191   }
42192   {
42193     try {
42194       result = Dali::NativeImage::New(*arg1);
42195     } catch (std::out_of_range& e) {
42196       {
42197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42198       };
42199     } catch (std::exception& e) {
42200       {
42201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42202       };
42203     } catch (...) {
42204       {
42205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42206       };
42207     }
42208   }
42209   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42215   void * jresult ;
42216   Dali::BaseHandle arg1 ;
42217   Dali::BaseHandle *argp1 ;
42218   Dali::NativeImage result;
42219
42220   argp1 = (Dali::BaseHandle *)jarg1;
42221   if (!argp1) {
42222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42223     return 0;
42224   }
42225   arg1 = *argp1;
42226   {
42227     try {
42228       result = Dali::NativeImage::DownCast(arg1);
42229     } catch (std::out_of_range& e) {
42230       {
42231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42232       };
42233     } catch (std::exception& e) {
42234       {
42235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (...) {
42238       {
42239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42240       };
42241     }
42242   }
42243   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42244   return jresult;
42245 }
42246
42247
42248 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42249   char * jresult ;
42250   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42251   char *result = 0 ;
42252
42253   arg1 = (Dali::NativeImage *)jarg1;
42254   {
42255     try {
42256       result = (char *)(arg1)->GetCustomFragmentPreFix();
42257     } catch (std::out_of_range& e) {
42258       {
42259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42260       };
42261     } catch (std::exception& e) {
42262       {
42263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42268       };
42269     }
42270   }
42271   jresult = SWIG_csharp_string_callback((const char *)result);
42272   return jresult;
42273 }
42274
42275
42276 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42277   char * jresult ;
42278   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42279   char *result = 0 ;
42280
42281   arg1 = (Dali::NativeImage *)jarg1;
42282   {
42283     try {
42284       result = (char *)(arg1)->GetCustomSamplerTypename();
42285     } catch (std::out_of_range& e) {
42286       {
42287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42288       };
42289     } catch (std::exception& e) {
42290       {
42291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42292       };
42293     } catch (...) {
42294       {
42295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42296       };
42297     }
42298   }
42299   jresult = SWIG_csharp_string_callback((const char *)result);
42300   return jresult;
42301 }
42302
42303
42304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42305   unsigned int jresult ;
42306   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42307   bool result;
42308
42309   arg1 = (Dali::NativeImageInterface *)jarg1;
42310   {
42311     try {
42312       result = (bool)(arg1)->GlExtensionCreate();
42313     } catch (std::out_of_range& e) {
42314       {
42315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (std::exception& e) {
42318       {
42319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42320       };
42321     } catch (...) {
42322       {
42323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42324       };
42325     }
42326   }
42327   jresult = result;
42328   return jresult;
42329 }
42330
42331
42332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42333   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42334
42335   arg1 = (Dali::NativeImageInterface *)jarg1;
42336   {
42337     try {
42338       (arg1)->GlExtensionDestroy();
42339     } catch (std::out_of_range& e) {
42340       {
42341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42342       };
42343     } catch (std::exception& e) {
42344       {
42345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42350       };
42351     }
42352   }
42353 }
42354
42355
42356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42357   unsigned int jresult ;
42358   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42359   unsigned int result;
42360
42361   arg1 = (Dali::NativeImageInterface *)jarg1;
42362   {
42363     try {
42364       result = (unsigned int)(arg1)->TargetTexture();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = result;
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42385   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42386
42387   arg1 = (Dali::NativeImageInterface *)jarg1;
42388   {
42389     try {
42390       (arg1)->PrepareTexture();
42391     } catch (std::out_of_range& e) {
42392       {
42393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42394       };
42395     } catch (std::exception& e) {
42396       {
42397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42398       };
42399     } catch (...) {
42400       {
42401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42402       };
42403     }
42404   }
42405 }
42406
42407
42408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42409   unsigned int jresult ;
42410   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42411   unsigned int result;
42412
42413   arg1 = (Dali::NativeImageInterface *)jarg1;
42414   {
42415     try {
42416       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42417     } catch (std::out_of_range& e) {
42418       {
42419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42420       };
42421     } catch (std::exception& e) {
42422       {
42423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42424       };
42425     } catch (...) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42428       };
42429     }
42430   }
42431   jresult = result;
42432   return jresult;
42433 }
42434
42435
42436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42437   unsigned int jresult ;
42438   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42439   unsigned int result;
42440
42441   arg1 = (Dali::NativeImageInterface *)jarg1;
42442   {
42443     try {
42444       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42445     } catch (std::out_of_range& e) {
42446       {
42447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (std::exception& e) {
42450       {
42451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (...) {
42454       {
42455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42456       };
42457     }
42458   }
42459   jresult = result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42465   unsigned int jresult ;
42466   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42467   bool result;
42468
42469   arg1 = (Dali::NativeImageInterface *)jarg1;
42470   {
42471     try {
42472       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42473     } catch (std::out_of_range& e) {
42474       {
42475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42476       };
42477     } catch (std::exception& e) {
42478       {
42479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42480       };
42481     } catch (...) {
42482       {
42483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42484       };
42485     }
42486   }
42487   jresult = result;
42488   return jresult;
42489 }
42490
42491
42492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42493   void * jresult ;
42494   std::string *arg1 = 0 ;
42495   Dali::ImageDimensions result;
42496
42497   if (!jarg1) {
42498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42499     return 0;
42500   }
42501   std::string arg1_str(jarg1);
42502   arg1 = &arg1_str;
42503   {
42504     try {
42505       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42517       };
42518     }
42519   }
42520   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42521
42522   //argout typemap for const std::string&
42523
42524   return jresult;
42525 }
42526
42527
42528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42529   void * jresult ;
42530   Dali::ResourceImage *result = 0 ;
42531
42532   {
42533     try {
42534       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42535     } catch (std::out_of_range& e) {
42536       {
42537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42538       };
42539     } catch (std::exception& e) {
42540       {
42541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42542       };
42543     } catch (...) {
42544       {
42545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42546       };
42547     }
42548   }
42549   jresult = (void *)result;
42550   return jresult;
42551 }
42552
42553
42554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42555   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42556
42557   arg1 = (Dali::ResourceImage *)jarg1;
42558   {
42559     try {
42560       delete arg1;
42561     } catch (std::out_of_range& e) {
42562       {
42563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42564       };
42565     } catch (std::exception& e) {
42566       {
42567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42568       };
42569     } catch (...) {
42570       {
42571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42572       };
42573     }
42574   }
42575 }
42576
42577
42578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42579   void * jresult ;
42580   Dali::ResourceImage *arg1 = 0 ;
42581   Dali::ResourceImage *result = 0 ;
42582
42583   arg1 = (Dali::ResourceImage *)jarg1;
42584   if (!arg1) {
42585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42586     return 0;
42587   }
42588   {
42589     try {
42590       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42591     } catch (std::out_of_range& e) {
42592       {
42593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (std::exception& e) {
42596       {
42597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42602       };
42603     }
42604   }
42605   jresult = (void *)result;
42606   return jresult;
42607 }
42608
42609
42610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42611   void * jresult ;
42612   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42613   Dali::ResourceImage *arg2 = 0 ;
42614   Dali::ResourceImage *result = 0 ;
42615
42616   arg1 = (Dali::ResourceImage *)jarg1;
42617   arg2 = (Dali::ResourceImage *)jarg2;
42618   if (!arg2) {
42619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42620     return 0;
42621   }
42622   {
42623     try {
42624       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42625     } catch (std::out_of_range& e) {
42626       {
42627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42628       };
42629     } catch (std::exception& e) {
42630       {
42631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42632       };
42633     } catch (...) {
42634       {
42635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42636       };
42637     }
42638   }
42639   jresult = (void *)result;
42640   return jresult;
42641 }
42642
42643
42644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42645   void * jresult ;
42646   std::string *arg1 = 0 ;
42647   bool arg2 ;
42648   Dali::ResourceImage result;
42649
42650   if (!jarg1) {
42651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42652     return 0;
42653   }
42654   std::string arg1_str(jarg1);
42655   arg1 = &arg1_str;
42656   arg2 = jarg2 ? true : false;
42657   {
42658     try {
42659       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42660     } catch (std::out_of_range& e) {
42661       {
42662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42663       };
42664     } catch (std::exception& e) {
42665       {
42666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42667       };
42668     } catch (...) {
42669       {
42670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42671       };
42672     }
42673   }
42674   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42675
42676   //argout typemap for const std::string&
42677
42678   return jresult;
42679 }
42680
42681
42682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42683   void * jresult ;
42684   std::string *arg1 = 0 ;
42685   Dali::ResourceImage result;
42686
42687   if (!jarg1) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42689     return 0;
42690   }
42691   std::string arg1_str(jarg1);
42692   arg1 = &arg1_str;
42693   {
42694     try {
42695       result = Dali::ResourceImage::New((std::string const &)*arg1);
42696     } catch (std::out_of_range& e) {
42697       {
42698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42699       };
42700     } catch (std::exception& e) {
42701       {
42702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42703       };
42704     } catch (...) {
42705       {
42706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42707       };
42708     }
42709   }
42710   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42711
42712   //argout typemap for const std::string&
42713
42714   return jresult;
42715 }
42716
42717
42718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42719   void * jresult ;
42720   std::string *arg1 = 0 ;
42721   Dali::ImageDimensions arg2 ;
42722   Dali::FittingMode::Type arg3 ;
42723   Dali::SamplingMode::Type arg4 ;
42724   bool arg5 ;
42725   Dali::ImageDimensions *argp2 ;
42726   Dali::ResourceImage result;
42727
42728   if (!jarg1) {
42729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42730     return 0;
42731   }
42732   std::string arg1_str(jarg1);
42733   arg1 = &arg1_str;
42734   argp2 = (Dali::ImageDimensions *)jarg2;
42735   if (!argp2) {
42736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42737     return 0;
42738   }
42739   arg2 = *argp2;
42740   arg3 = (Dali::FittingMode::Type)jarg3;
42741   arg4 = (Dali::SamplingMode::Type)jarg4;
42742   arg5 = jarg5 ? true : false;
42743   {
42744     try {
42745       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42746     } catch (std::out_of_range& e) {
42747       {
42748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42749       };
42750     } catch (std::exception& e) {
42751       {
42752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42753       };
42754     } catch (...) {
42755       {
42756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42757       };
42758     }
42759   }
42760   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42761
42762   //argout typemap for const std::string&
42763
42764   return jresult;
42765 }
42766
42767
42768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42769   void * jresult ;
42770   std::string *arg1 = 0 ;
42771   Dali::ImageDimensions arg2 ;
42772   Dali::FittingMode::Type arg3 ;
42773   Dali::SamplingMode::Type arg4 ;
42774   Dali::ImageDimensions *argp2 ;
42775   Dali::ResourceImage result;
42776
42777   if (!jarg1) {
42778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42779     return 0;
42780   }
42781   std::string arg1_str(jarg1);
42782   arg1 = &arg1_str;
42783   argp2 = (Dali::ImageDimensions *)jarg2;
42784   if (!argp2) {
42785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42786     return 0;
42787   }
42788   arg2 = *argp2;
42789   arg3 = (Dali::FittingMode::Type)jarg3;
42790   arg4 = (Dali::SamplingMode::Type)jarg4;
42791   {
42792     try {
42793       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42794     } catch (std::out_of_range& e) {
42795       {
42796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42797       };
42798     } catch (std::exception& e) {
42799       {
42800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42801       };
42802     } catch (...) {
42803       {
42804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42805       };
42806     }
42807   }
42808   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42809
42810   //argout typemap for const std::string&
42811
42812   return jresult;
42813 }
42814
42815
42816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42817   void * jresult ;
42818   std::string *arg1 = 0 ;
42819   Dali::ImageDimensions arg2 ;
42820   Dali::FittingMode::Type arg3 ;
42821   Dali::ImageDimensions *argp2 ;
42822   Dali::ResourceImage result;
42823
42824   if (!jarg1) {
42825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42826     return 0;
42827   }
42828   std::string arg1_str(jarg1);
42829   arg1 = &arg1_str;
42830   argp2 = (Dali::ImageDimensions *)jarg2;
42831   if (!argp2) {
42832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42833     return 0;
42834   }
42835   arg2 = *argp2;
42836   arg3 = (Dali::FittingMode::Type)jarg3;
42837   {
42838     try {
42839       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42840     } catch (std::out_of_range& e) {
42841       {
42842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42843       };
42844     } catch (std::exception& e) {
42845       {
42846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (...) {
42849       {
42850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42851       };
42852     }
42853   }
42854   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42855
42856   //argout typemap for const std::string&
42857
42858   return jresult;
42859 }
42860
42861
42862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42863   void * jresult ;
42864   std::string *arg1 = 0 ;
42865   Dali::ImageDimensions arg2 ;
42866   Dali::ImageDimensions *argp2 ;
42867   Dali::ResourceImage result;
42868
42869   if (!jarg1) {
42870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42871     return 0;
42872   }
42873   std::string arg1_str(jarg1);
42874   arg1 = &arg1_str;
42875   argp2 = (Dali::ImageDimensions *)jarg2;
42876   if (!argp2) {
42877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42878     return 0;
42879   }
42880   arg2 = *argp2;
42881   {
42882     try {
42883       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42884     } catch (std::out_of_range& e) {
42885       {
42886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (std::exception& e) {
42889       {
42890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42899
42900   //argout typemap for const std::string&
42901
42902   return jresult;
42903 }
42904
42905
42906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42907   void * jresult ;
42908   Dali::BaseHandle arg1 ;
42909   Dali::BaseHandle *argp1 ;
42910   Dali::ResourceImage result;
42911
42912   argp1 = (Dali::BaseHandle *)jarg1;
42913   if (!argp1) {
42914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42915     return 0;
42916   }
42917   arg1 = *argp1;
42918   {
42919     try {
42920       result = Dali::ResourceImage::DownCast(arg1);
42921     } catch (std::out_of_range& e) {
42922       {
42923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42924       };
42925     } catch (std::exception& e) {
42926       {
42927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42928       };
42929     } catch (...) {
42930       {
42931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42932       };
42933     }
42934   }
42935   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42936   return jresult;
42937 }
42938
42939
42940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42941   int jresult ;
42942   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42943   Dali::LoadingState result;
42944
42945   arg1 = (Dali::ResourceImage *)jarg1;
42946   {
42947     try {
42948       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42949     } catch (std::out_of_range& e) {
42950       {
42951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42952       };
42953     } catch (std::exception& e) {
42954       {
42955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42956       };
42957     } catch (...) {
42958       {
42959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42960       };
42961     }
42962   }
42963   jresult = (int)result;
42964   return jresult;
42965 }
42966
42967
42968 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42969   char * jresult ;
42970   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42971   std::string result;
42972
42973   arg1 = (Dali::ResourceImage *)jarg1;
42974   {
42975     try {
42976       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42977     } catch (std::out_of_range& e) {
42978       {
42979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42980       };
42981     } catch (std::exception& e) {
42982       {
42983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42984       };
42985     } catch (...) {
42986       {
42987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42988       };
42989     }
42990   }
42991   jresult = SWIG_csharp_string_callback((&result)->c_str());
42992   return jresult;
42993 }
42994
42995
42996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42997   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42998
42999   arg1 = (Dali::ResourceImage *)jarg1;
43000   {
43001     try {
43002       (arg1)->Reload();
43003     } catch (std::out_of_range& e) {
43004       {
43005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43006       };
43007     } catch (std::exception& e) {
43008       {
43009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43010       };
43011     } catch (...) {
43012       {
43013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43014       };
43015     }
43016   }
43017 }
43018
43019
43020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43021   void * jresult ;
43022   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43023   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43024
43025   arg1 = (Dali::ResourceImage *)jarg1;
43026   {
43027     try {
43028       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (void *)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43049   void * jresult ;
43050   Dali::FrameBufferImage *result = 0 ;
43051
43052   {
43053     try {
43054       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43055     } catch (std::out_of_range& e) {
43056       {
43057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (std::exception& e) {
43060       {
43061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (...) {
43064       {
43065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43066       };
43067     }
43068   }
43069   jresult = (void *)result;
43070   return jresult;
43071 }
43072
43073
43074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43075   void * jresult ;
43076   unsigned int arg1 ;
43077   unsigned int arg2 ;
43078   Dali::Pixel::Format arg3 ;
43079   Dali::RenderBuffer::Format arg4 ;
43080   Dali::FrameBufferImage result;
43081
43082   arg1 = (unsigned int)jarg1;
43083   arg2 = (unsigned int)jarg2;
43084   arg3 = (Dali::Pixel::Format)jarg3;
43085   arg4 = (Dali::RenderBuffer::Format)jarg4;
43086   {
43087     try {
43088       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43089     } catch (std::out_of_range& e) {
43090       {
43091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (std::exception& e) {
43094       {
43095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43096       };
43097     } catch (...) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43100       };
43101     }
43102   }
43103   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43104   return jresult;
43105 }
43106
43107
43108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43109   void * jresult ;
43110   unsigned int arg1 ;
43111   unsigned int arg2 ;
43112   Dali::Pixel::Format arg3 ;
43113   Dali::FrameBufferImage result;
43114
43115   arg1 = (unsigned int)jarg1;
43116   arg2 = (unsigned int)jarg2;
43117   arg3 = (Dali::Pixel::Format)jarg3;
43118   {
43119     try {
43120       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43121     } catch (std::out_of_range& e) {
43122       {
43123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43124       };
43125     } catch (std::exception& e) {
43126       {
43127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43128       };
43129     } catch (...) {
43130       {
43131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43132       };
43133     }
43134   }
43135   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43141   void * jresult ;
43142   unsigned int arg1 ;
43143   unsigned int arg2 ;
43144   Dali::FrameBufferImage result;
43145
43146   arg1 = (unsigned int)jarg1;
43147   arg2 = (unsigned int)jarg2;
43148   {
43149     try {
43150       result = Dali::FrameBufferImage::New(arg1,arg2);
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (...) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43162       };
43163     }
43164   }
43165   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43166   return jresult;
43167 }
43168
43169
43170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43171   void * jresult ;
43172   unsigned int arg1 ;
43173   Dali::FrameBufferImage result;
43174
43175   arg1 = (unsigned int)jarg1;
43176   {
43177     try {
43178       result = Dali::FrameBufferImage::New(arg1);
43179     } catch (std::out_of_range& e) {
43180       {
43181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43182       };
43183     } catch (std::exception& e) {
43184       {
43185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43190       };
43191     }
43192   }
43193   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43194   return jresult;
43195 }
43196
43197
43198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43199   void * jresult ;
43200   Dali::FrameBufferImage result;
43201
43202   {
43203     try {
43204       result = Dali::FrameBufferImage::New();
43205     } catch (std::out_of_range& e) {
43206       {
43207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (std::exception& e) {
43210       {
43211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43212       };
43213     } catch (...) {
43214       {
43215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43216       };
43217     }
43218   }
43219   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43220   return jresult;
43221 }
43222
43223
43224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43225   void * jresult ;
43226   Dali::NativeImageInterface *arg1 = 0 ;
43227   Dali::FrameBufferImage result;
43228
43229   arg1 = (Dali::NativeImageInterface *)jarg1;
43230   if (!arg1) {
43231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43232     return 0;
43233   }
43234   {
43235     try {
43236       result = Dali::FrameBufferImage::New(*arg1);
43237     } catch (std::out_of_range& e) {
43238       {
43239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43240       };
43241     } catch (std::exception& e) {
43242       {
43243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43244       };
43245     } catch (...) {
43246       {
43247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43248       };
43249     }
43250   }
43251   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43252   return jresult;
43253 }
43254
43255
43256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43257   void * jresult ;
43258   Dali::BaseHandle arg1 ;
43259   Dali::BaseHandle *argp1 ;
43260   Dali::FrameBufferImage result;
43261
43262   argp1 = (Dali::BaseHandle *)jarg1;
43263   if (!argp1) {
43264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43265     return 0;
43266   }
43267   arg1 = *argp1;
43268   {
43269     try {
43270       result = Dali::FrameBufferImage::DownCast(arg1);
43271     } catch (std::out_of_range& e) {
43272       {
43273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (std::exception& e) {
43276       {
43277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (...) {
43280       {
43281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43282       };
43283     }
43284   }
43285   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43286   return jresult;
43287 }
43288
43289
43290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43291   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43292
43293   arg1 = (Dali::FrameBufferImage *)jarg1;
43294   {
43295     try {
43296       delete arg1;
43297     } catch (std::out_of_range& e) {
43298       {
43299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43300       };
43301     } catch (std::exception& e) {
43302       {
43303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43304       };
43305     } catch (...) {
43306       {
43307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43308       };
43309     }
43310   }
43311 }
43312
43313
43314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43315   void * jresult ;
43316   Dali::FrameBufferImage *arg1 = 0 ;
43317   Dali::FrameBufferImage *result = 0 ;
43318
43319   arg1 = (Dali::FrameBufferImage *)jarg1;
43320   if (!arg1) {
43321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43322     return 0;
43323   }
43324   {
43325     try {
43326       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43327     } catch (std::out_of_range& e) {
43328       {
43329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43330       };
43331     } catch (std::exception& e) {
43332       {
43333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43334       };
43335     } catch (...) {
43336       {
43337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43338       };
43339     }
43340   }
43341   jresult = (void *)result;
43342   return jresult;
43343 }
43344
43345
43346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43347   void * jresult ;
43348   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43349   Dali::FrameBufferImage *arg2 = 0 ;
43350   Dali::FrameBufferImage *result = 0 ;
43351
43352   arg1 = (Dali::FrameBufferImage *)jarg1;
43353   arg2 = (Dali::FrameBufferImage *)jarg2;
43354   if (!arg2) {
43355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43356     return 0;
43357   }
43358   {
43359     try {
43360       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43368       };
43369     } catch (...) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43372       };
43373     }
43374   }
43375   jresult = (void *)result;
43376   return jresult;
43377 }
43378
43379
43380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43381   void * jresult ;
43382   Dali::NinePatchImage *result = 0 ;
43383
43384   {
43385     try {
43386       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43387     } catch (std::out_of_range& e) {
43388       {
43389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43390       };
43391     } catch (std::exception& e) {
43392       {
43393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43394       };
43395     } catch (...) {
43396       {
43397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43398       };
43399     }
43400   }
43401   jresult = (void *)result;
43402   return jresult;
43403 }
43404
43405
43406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43407   void * jresult ;
43408   std::string *arg1 = 0 ;
43409   Dali::NinePatchImage result;
43410
43411   if (!jarg1) {
43412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43413     return 0;
43414   }
43415   std::string arg1_str(jarg1);
43416   arg1 = &arg1_str;
43417   {
43418     try {
43419       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43420     } catch (std::out_of_range& e) {
43421       {
43422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43423       };
43424     } catch (std::exception& e) {
43425       {
43426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43427       };
43428     } catch (...) {
43429       {
43430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43431       };
43432     }
43433   }
43434   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43435
43436   //argout typemap for const std::string&
43437
43438   return jresult;
43439 }
43440
43441
43442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43443   void * jresult ;
43444   Dali::BaseHandle arg1 ;
43445   Dali::BaseHandle *argp1 ;
43446   Dali::NinePatchImage result;
43447
43448   argp1 = (Dali::BaseHandle *)jarg1;
43449   if (!argp1) {
43450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43451     return 0;
43452   }
43453   arg1 = *argp1;
43454   {
43455     try {
43456       result = Dali::NinePatchImage::DownCast(arg1);
43457     } catch (std::out_of_range& e) {
43458       {
43459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (std::exception& e) {
43462       {
43463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43468       };
43469     }
43470   }
43471   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43472   return jresult;
43473 }
43474
43475
43476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43477   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43478
43479   arg1 = (Dali::NinePatchImage *)jarg1;
43480   {
43481     try {
43482       delete arg1;
43483     } catch (std::out_of_range& e) {
43484       {
43485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43486       };
43487     } catch (std::exception& e) {
43488       {
43489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43490       };
43491     } catch (...) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43494       };
43495     }
43496   }
43497 }
43498
43499
43500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43501   void * jresult ;
43502   Dali::NinePatchImage *arg1 = 0 ;
43503   Dali::NinePatchImage *result = 0 ;
43504
43505   arg1 = (Dali::NinePatchImage *)jarg1;
43506   if (!arg1) {
43507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43508     return 0;
43509   }
43510   {
43511     try {
43512       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43513     } catch (std::out_of_range& e) {
43514       {
43515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43516       };
43517     } catch (std::exception& e) {
43518       {
43519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (...) {
43522       {
43523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43524       };
43525     }
43526   }
43527   jresult = (void *)result;
43528   return jresult;
43529 }
43530
43531
43532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43533   void * jresult ;
43534   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43535   Dali::NinePatchImage *arg2 = 0 ;
43536   Dali::NinePatchImage *result = 0 ;
43537
43538   arg1 = (Dali::NinePatchImage *)jarg1;
43539   arg2 = (Dali::NinePatchImage *)jarg2;
43540   if (!arg2) {
43541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43542     return 0;
43543   }
43544   {
43545     try {
43546       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43547     } catch (std::out_of_range& e) {
43548       {
43549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43550       };
43551     } catch (std::exception& e) {
43552       {
43553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43554       };
43555     } catch (...) {
43556       {
43557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43558       };
43559     }
43560   }
43561   jresult = (void *)result;
43562   return jresult;
43563 }
43564
43565
43566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43567   void * jresult ;
43568   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43569   Dali::Vector4 result;
43570
43571   arg1 = (Dali::NinePatchImage *)jarg1;
43572   {
43573     try {
43574       result = (arg1)->GetStretchBorders();
43575     } catch (std::out_of_range& e) {
43576       {
43577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43578       };
43579     } catch (std::exception& e) {
43580       {
43581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43582       };
43583     } catch (...) {
43584       {
43585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43586       };
43587     }
43588   }
43589   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43590   return jresult;
43591 }
43592
43593
43594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43595   void * jresult ;
43596   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43597   Dali::NinePatchImage::StretchRanges *result = 0 ;
43598
43599   arg1 = (Dali::NinePatchImage *)jarg1;
43600   {
43601     try {
43602       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43603     } catch (std::out_of_range& e) {
43604       {
43605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (std::exception& e) {
43608       {
43609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43610       };
43611     } catch (...) {
43612       {
43613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43614       };
43615     }
43616   }
43617   jresult = (void *)result;
43618   return jresult;
43619 }
43620
43621
43622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43623   void * jresult ;
43624   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43625   Dali::NinePatchImage::StretchRanges *result = 0 ;
43626
43627   arg1 = (Dali::NinePatchImage *)jarg1;
43628   {
43629     try {
43630       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43631     } catch (std::out_of_range& e) {
43632       {
43633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43634       };
43635     } catch (std::exception& e) {
43636       {
43637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43638       };
43639     } catch (...) {
43640       {
43641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43642       };
43643     }
43644   }
43645   jresult = (void *)result;
43646   return jresult;
43647 }
43648
43649
43650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43651   void * jresult ;
43652   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43653   Dali::Rect< int > result;
43654
43655   arg1 = (Dali::NinePatchImage *)jarg1;
43656   {
43657     try {
43658       result = (arg1)->GetChildRectangle();
43659     } catch (std::out_of_range& e) {
43660       {
43661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (std::exception& e) {
43664       {
43665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43670       };
43671     }
43672   }
43673   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43674   return jresult;
43675 }
43676
43677
43678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43679   void * jresult ;
43680   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43681   Dali::BufferImage result;
43682
43683   arg1 = (Dali::NinePatchImage *)jarg1;
43684   {
43685     try {
43686       result = (arg1)->CreateCroppedBufferImage();
43687     } catch (std::out_of_range& e) {
43688       {
43689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (std::exception& e) {
43692       {
43693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43694       };
43695     } catch (...) {
43696       {
43697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43698       };
43699     }
43700   }
43701   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43702   return jresult;
43703 }
43704
43705
43706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43707   unsigned int jresult ;
43708   std::string *arg1 = 0 ;
43709   bool result;
43710
43711   if (!jarg1) {
43712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43713     return 0;
43714   }
43715   std::string arg1_str(jarg1);
43716   arg1 = &arg1_str;
43717   {
43718     try {
43719       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43720     } catch (std::out_of_range& e) {
43721       {
43722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43723       };
43724     } catch (std::exception& e) {
43725       {
43726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43727       };
43728     } catch (...) {
43729       {
43730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43731       };
43732     }
43733   }
43734   jresult = result;
43735
43736   //argout typemap for const std::string&
43737
43738   return jresult;
43739 }
43740
43741
43742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43743   int jresult ;
43744   int result;
43745
43746   result = (int)Dali::CameraActor::Property::TYPE;
43747   jresult = (int)result;
43748   return jresult;
43749 }
43750
43751
43752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43753   int jresult ;
43754   int result;
43755
43756   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43757   jresult = (int)result;
43758   return jresult;
43759 }
43760
43761
43762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43763   int jresult ;
43764   int result;
43765
43766   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43767   jresult = (int)result;
43768   return jresult;
43769 }
43770
43771
43772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43773   int jresult ;
43774   int result;
43775
43776   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43777   jresult = (int)result;
43778   return jresult;
43779 }
43780
43781
43782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43783   int jresult ;
43784   int result;
43785
43786   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43787   jresult = (int)result;
43788   return jresult;
43789 }
43790
43791
43792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43793   int jresult ;
43794   int result;
43795
43796   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43797   jresult = (int)result;
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43803   int jresult ;
43804   int result;
43805
43806   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43807   jresult = (int)result;
43808   return jresult;
43809 }
43810
43811
43812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43813   int jresult ;
43814   int result;
43815
43816   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43817   jresult = (int)result;
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43823   int jresult ;
43824   int result;
43825
43826   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43827   jresult = (int)result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43833   int jresult ;
43834   int result;
43835
43836   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43837   jresult = (int)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43843   int jresult ;
43844   int result;
43845
43846   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43847   jresult = (int)result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43853   int jresult ;
43854   int result;
43855
43856   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43857   jresult = (int)result;
43858   return jresult;
43859 }
43860
43861
43862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43863   int jresult ;
43864   int result;
43865
43866   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43867   jresult = (int)result;
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43873   int jresult ;
43874   int result;
43875
43876   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43877   jresult = (int)result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43883   void * jresult ;
43884   Dali::CameraActor::Property *result = 0 ;
43885
43886   {
43887     try {
43888       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43889     } catch (std::out_of_range& e) {
43890       {
43891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43892       };
43893     } catch (std::exception& e) {
43894       {
43895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43896       };
43897     } catch (...) {
43898       {
43899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43900       };
43901     }
43902   }
43903   jresult = (void *)result;
43904   return jresult;
43905 }
43906
43907
43908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43909   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43910
43911   arg1 = (Dali::CameraActor::Property *)jarg1;
43912   {
43913     try {
43914       delete arg1;
43915     } catch (std::out_of_range& e) {
43916       {
43917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43918       };
43919     } catch (std::exception& e) {
43920       {
43921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43922       };
43923     } catch (...) {
43924       {
43925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43926       };
43927     }
43928   }
43929 }
43930
43931
43932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43933   void * jresult ;
43934   Dali::CameraActor *result = 0 ;
43935
43936   {
43937     try {
43938       result = (Dali::CameraActor *)new Dali::CameraActor();
43939     } catch (std::out_of_range& e) {
43940       {
43941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (std::exception& e) {
43944       {
43945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (...) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43950       };
43951     }
43952   }
43953   jresult = (void *)result;
43954   return jresult;
43955 }
43956
43957
43958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43959   void * jresult ;
43960   Dali::CameraActor result;
43961
43962   {
43963     try {
43964       result = Dali::CameraActor::New();
43965     } catch (std::out_of_range& e) {
43966       {
43967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43968       };
43969     } catch (std::exception& e) {
43970       {
43971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43972       };
43973     } catch (...) {
43974       {
43975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43976       };
43977     }
43978   }
43979   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43980   return jresult;
43981 }
43982
43983
43984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43985   void * jresult ;
43986   Dali::Size *arg1 = 0 ;
43987   Dali::CameraActor result;
43988
43989   arg1 = (Dali::Size *)jarg1;
43990   if (!arg1) {
43991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43992     return 0;
43993   }
43994   {
43995     try {
43996       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43997     } catch (std::out_of_range& e) {
43998       {
43999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44000       };
44001     } catch (std::exception& e) {
44002       {
44003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44004       };
44005     } catch (...) {
44006       {
44007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44008       };
44009     }
44010   }
44011   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44017   void * jresult ;
44018   Dali::BaseHandle arg1 ;
44019   Dali::BaseHandle *argp1 ;
44020   Dali::CameraActor result;
44021
44022   argp1 = (Dali::BaseHandle *)jarg1;
44023   if (!argp1) {
44024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44025     return 0;
44026   }
44027   arg1 = *argp1;
44028   {
44029     try {
44030       result = Dali::CameraActor::DownCast(arg1);
44031     } catch (std::out_of_range& e) {
44032       {
44033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44034       };
44035     } catch (std::exception& e) {
44036       {
44037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44038       };
44039     } catch (...) {
44040       {
44041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44042       };
44043     }
44044   }
44045   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44046   return jresult;
44047 }
44048
44049
44050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44051   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44052
44053   arg1 = (Dali::CameraActor *)jarg1;
44054   {
44055     try {
44056       delete arg1;
44057     } catch (std::out_of_range& e) {
44058       {
44059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44060       };
44061     } catch (std::exception& e) {
44062       {
44063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44064       };
44065     } catch (...) {
44066       {
44067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44068       };
44069     }
44070   }
44071 }
44072
44073
44074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44075   void * jresult ;
44076   Dali::CameraActor *arg1 = 0 ;
44077   Dali::CameraActor *result = 0 ;
44078
44079   arg1 = (Dali::CameraActor *)jarg1;
44080   if (!arg1) {
44081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44082     return 0;
44083   }
44084   {
44085     try {
44086       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44087     } catch (std::out_of_range& e) {
44088       {
44089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44090       };
44091     } catch (std::exception& e) {
44092       {
44093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44094       };
44095     } catch (...) {
44096       {
44097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44098       };
44099     }
44100   }
44101   jresult = (void *)result;
44102   return jresult;
44103 }
44104
44105
44106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44107   void * jresult ;
44108   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44109   Dali::CameraActor *arg2 = 0 ;
44110   Dali::CameraActor *result = 0 ;
44111
44112   arg1 = (Dali::CameraActor *)jarg1;
44113   arg2 = (Dali::CameraActor *)jarg2;
44114   if (!arg2) {
44115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44116     return 0;
44117   }
44118   {
44119     try {
44120       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44121     } catch (std::out_of_range& e) {
44122       {
44123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44124       };
44125     } catch (std::exception& e) {
44126       {
44127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44128       };
44129     } catch (...) {
44130       {
44131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44132       };
44133     }
44134   }
44135   jresult = (void *)result;
44136   return jresult;
44137 }
44138
44139
44140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44141   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44142   Dali::Camera::Type arg2 ;
44143
44144   arg1 = (Dali::CameraActor *)jarg1;
44145   arg2 = (Dali::Camera::Type)jarg2;
44146   {
44147     try {
44148       (arg1)->SetType(arg2);
44149     } catch (std::out_of_range& e) {
44150       {
44151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44152       };
44153     } catch (std::exception& e) {
44154       {
44155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44156       };
44157     } catch (...) {
44158       {
44159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44160       };
44161     }
44162   }
44163 }
44164
44165
44166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44167   int jresult ;
44168   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44169   Dali::Camera::Type result;
44170
44171   arg1 = (Dali::CameraActor *)jarg1;
44172   {
44173     try {
44174       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44175     } catch (std::out_of_range& e) {
44176       {
44177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44178       };
44179     } catch (std::exception& e) {
44180       {
44181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44182       };
44183     } catch (...) {
44184       {
44185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44186       };
44187     }
44188   }
44189   jresult = (int)result;
44190   return jresult;
44191 }
44192
44193
44194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44195   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44196   Dali::Camera::ProjectionMode arg2 ;
44197
44198   arg1 = (Dali::CameraActor *)jarg1;
44199   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44200   {
44201     try {
44202       (arg1)->SetProjectionMode(arg2);
44203     } catch (std::out_of_range& e) {
44204       {
44205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44206       };
44207     } catch (std::exception& e) {
44208       {
44209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (...) {
44212       {
44213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44214       };
44215     }
44216   }
44217 }
44218
44219
44220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44221   int jresult ;
44222   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44223   Dali::Camera::ProjectionMode result;
44224
44225   arg1 = (Dali::CameraActor *)jarg1;
44226   {
44227     try {
44228       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44240       };
44241     }
44242   }
44243   jresult = (int)result;
44244   return jresult;
44245 }
44246
44247
44248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44250   float arg2 ;
44251
44252   arg1 = (Dali::CameraActor *)jarg1;
44253   arg2 = (float)jarg2;
44254   {
44255     try {
44256       (arg1)->SetFieldOfView(arg2);
44257     } catch (std::out_of_range& e) {
44258       {
44259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (std::exception& e) {
44262       {
44263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271 }
44272
44273
44274 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44275   float jresult ;
44276   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44277   float result;
44278
44279   arg1 = (Dali::CameraActor *)jarg1;
44280   {
44281     try {
44282       result = (float)(arg1)->GetFieldOfView();
44283     } catch (std::out_of_range& e) {
44284       {
44285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44286       };
44287     } catch (std::exception& e) {
44288       {
44289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44290       };
44291     } catch (...) {
44292       {
44293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44294       };
44295     }
44296   }
44297   jresult = result;
44298   return jresult;
44299 }
44300
44301
44302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44303   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44304   float arg2 ;
44305
44306   arg1 = (Dali::CameraActor *)jarg1;
44307   arg2 = (float)jarg2;
44308   {
44309     try {
44310       (arg1)->SetAspectRatio(arg2);
44311     } catch (std::out_of_range& e) {
44312       {
44313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44314       };
44315     } catch (std::exception& e) {
44316       {
44317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44318       };
44319     } catch (...) {
44320       {
44321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44322       };
44323     }
44324   }
44325 }
44326
44327
44328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44329   float jresult ;
44330   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44331   float result;
44332
44333   arg1 = (Dali::CameraActor *)jarg1;
44334   {
44335     try {
44336       result = (float)(arg1)->GetAspectRatio();
44337     } catch (std::out_of_range& e) {
44338       {
44339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44340       };
44341     } catch (std::exception& e) {
44342       {
44343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44344       };
44345     } catch (...) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44348       };
44349     }
44350   }
44351   jresult = result;
44352   return jresult;
44353 }
44354
44355
44356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44357   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44358   float arg2 ;
44359
44360   arg1 = (Dali::CameraActor *)jarg1;
44361   arg2 = (float)jarg2;
44362   {
44363     try {
44364       (arg1)->SetNearClippingPlane(arg2);
44365     } catch (std::out_of_range& e) {
44366       {
44367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44368       };
44369     } catch (std::exception& e) {
44370       {
44371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44372       };
44373     } catch (...) {
44374       {
44375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44376       };
44377     }
44378   }
44379 }
44380
44381
44382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44383   float jresult ;
44384   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44385   float result;
44386
44387   arg1 = (Dali::CameraActor *)jarg1;
44388   {
44389     try {
44390       result = (float)(arg1)->GetNearClippingPlane();
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44398       };
44399     } catch (...) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44402       };
44403     }
44404   }
44405   jresult = result;
44406   return jresult;
44407 }
44408
44409
44410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44411   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44412   float arg2 ;
44413
44414   arg1 = (Dali::CameraActor *)jarg1;
44415   arg2 = (float)jarg2;
44416   {
44417     try {
44418       (arg1)->SetFarClippingPlane(arg2);
44419     } catch (std::out_of_range& e) {
44420       {
44421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44422       };
44423     } catch (std::exception& e) {
44424       {
44425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44426       };
44427     } catch (...) {
44428       {
44429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44430       };
44431     }
44432   }
44433 }
44434
44435
44436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44437   float jresult ;
44438   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44439   float result;
44440
44441   arg1 = (Dali::CameraActor *)jarg1;
44442   {
44443     try {
44444       result = (float)(arg1)->GetFarClippingPlane();
44445     } catch (std::out_of_range& e) {
44446       {
44447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44448       };
44449     } catch (std::exception& e) {
44450       {
44451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44452       };
44453     } catch (...) {
44454       {
44455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44456       };
44457     }
44458   }
44459   jresult = result;
44460   return jresult;
44461 }
44462
44463
44464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44465   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44466   Dali::Vector3 *arg2 = 0 ;
44467
44468   arg1 = (Dali::CameraActor *)jarg1;
44469   arg2 = (Dali::Vector3 *)jarg2;
44470   if (!arg2) {
44471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44472     return ;
44473   }
44474   {
44475     try {
44476       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44477     } catch (std::out_of_range& e) {
44478       {
44479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (std::exception& e) {
44482       {
44483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44484       };
44485     } catch (...) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44488       };
44489     }
44490   }
44491 }
44492
44493
44494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44495   void * jresult ;
44496   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44497   Dali::Vector3 result;
44498
44499   arg1 = (Dali::CameraActor *)jarg1;
44500   {
44501     try {
44502       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44503     } catch (std::out_of_range& e) {
44504       {
44505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44506       };
44507     } catch (std::exception& e) {
44508       {
44509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44510       };
44511     } catch (...) {
44512       {
44513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44514       };
44515     }
44516   }
44517   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44518   return jresult;
44519 }
44520
44521
44522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44523   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44524   bool arg2 ;
44525
44526   arg1 = (Dali::CameraActor *)jarg1;
44527   arg2 = jarg2 ? true : false;
44528   {
44529     try {
44530       (arg1)->SetInvertYAxis(arg2);
44531     } catch (std::out_of_range& e) {
44532       {
44533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44534       };
44535     } catch (std::exception& e) {
44536       {
44537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44538       };
44539     } catch (...) {
44540       {
44541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44542       };
44543     }
44544   }
44545 }
44546
44547
44548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44549   unsigned int jresult ;
44550   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44551   bool result;
44552
44553   arg1 = (Dali::CameraActor *)jarg1;
44554   {
44555     try {
44556       result = (bool)(arg1)->GetInvertYAxis();
44557     } catch (std::out_of_range& e) {
44558       {
44559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44560       };
44561     } catch (std::exception& e) {
44562       {
44563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44568       };
44569     }
44570   }
44571   jresult = result;
44572   return jresult;
44573 }
44574
44575
44576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44577   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44578   Dali::Size *arg2 = 0 ;
44579
44580   arg1 = (Dali::CameraActor *)jarg1;
44581   arg2 = (Dali::Size *)jarg2;
44582   if (!arg2) {
44583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44584     return ;
44585   }
44586   {
44587     try {
44588       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44589     } catch (std::out_of_range& e) {
44590       {
44591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (std::exception& e) {
44594       {
44595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44596       };
44597     } catch (...) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44600       };
44601     }
44602   }
44603 }
44604
44605
44606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44608   Dali::Size *arg2 = 0 ;
44609
44610   arg1 = (Dali::CameraActor *)jarg1;
44611   arg2 = (Dali::Size *)jarg2;
44612   if (!arg2) {
44613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44614     return ;
44615   }
44616   {
44617     try {
44618       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44619     } catch (std::out_of_range& e) {
44620       {
44621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44622       };
44623     } catch (std::exception& e) {
44624       {
44625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44626       };
44627     } catch (...) {
44628       {
44629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44630       };
44631     }
44632   }
44633 }
44634
44635
44636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44637   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44638   float arg2 ;
44639   float arg3 ;
44640   float arg4 ;
44641   float arg5 ;
44642   float arg6 ;
44643   float arg7 ;
44644
44645   arg1 = (Dali::CameraActor *)jarg1;
44646   arg2 = (float)jarg2;
44647   arg3 = (float)jarg3;
44648   arg4 = (float)jarg4;
44649   arg5 = (float)jarg5;
44650   arg6 = (float)jarg6;
44651   arg7 = (float)jarg7;
44652   {
44653     try {
44654       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44662       };
44663     } catch (...) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44666       };
44667     }
44668   }
44669 }
44670
44671
44672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44673   void * jresult ;
44674   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44675
44676   {
44677     try {
44678       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44679     } catch (std::out_of_range& e) {
44680       {
44681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44682       };
44683     } catch (std::exception& e) {
44684       {
44685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44686       };
44687     } catch (...) {
44688       {
44689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44690       };
44691     }
44692   }
44693   jresult = (void *)result;
44694   return jresult;
44695 }
44696
44697
44698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44699   void * jresult ;
44700   std::string arg1 ;
44701   Dali::Property::Value arg2 ;
44702   Dali::Property::Value *argp2 ;
44703   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44704
44705   if (!jarg1) {
44706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44707     return 0;
44708   }
44709   (&arg1)->assign(jarg1);
44710   argp2 = (Dali::Property::Value *)jarg2;
44711   if (!argp2) {
44712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44713     return 0;
44714   }
44715   arg2 = *argp2;
44716   {
44717     try {
44718       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44719     } catch (std::out_of_range& e) {
44720       {
44721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44722       };
44723     } catch (std::exception& e) {
44724       {
44725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44726       };
44727     } catch (...) {
44728       {
44729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44730       };
44731     }
44732   }
44733   jresult = (void *)result;
44734   return jresult;
44735 }
44736
44737
44738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44739   void * jresult ;
44740   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44741   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44742
44743   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44744   if (!arg1) {
44745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44746     return 0;
44747   }
44748   {
44749     try {
44750       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);
44751     } catch (std::out_of_range& e) {
44752       {
44753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44754       };
44755     } catch (std::exception& e) {
44756       {
44757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44758       };
44759     } catch (...) {
44760       {
44761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44762       };
44763     }
44764   }
44765   jresult = (void *)result;
44766   return jresult;
44767 }
44768
44769
44770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44771   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44772   std::string *arg2 = 0 ;
44773
44774   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44775   if (!jarg2) {
44776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44777     return ;
44778   }
44779   std::string arg2_str(jarg2);
44780   arg2 = &arg2_str;
44781   if (arg1) (arg1)->first = *arg2;
44782
44783   //argout typemap for const std::string&
44784
44785 }
44786
44787
44788 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44789   char * jresult ;
44790   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44791   std::string *result = 0 ;
44792
44793   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44794   result = (std::string *) & ((arg1)->first);
44795   jresult = SWIG_csharp_string_callback(result->c_str());
44796   return jresult;
44797 }
44798
44799
44800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44801   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44802   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44803
44804   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44805   arg2 = (Dali::Property::Value *)jarg2;
44806   if (arg1) (arg1)->second = *arg2;
44807 }
44808
44809
44810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44811   void * jresult ;
44812   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44813   Dali::Property::Value *result = 0 ;
44814
44815   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44816   result = (Dali::Property::Value *)& ((arg1)->second);
44817   jresult = (void *)result;
44818   return jresult;
44819 }
44820
44821
44822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44823   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44824
44825   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44826   {
44827     try {
44828       delete arg1;
44829     } catch (std::out_of_range& e) {
44830       {
44831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44832       };
44833     } catch (std::exception& e) {
44834       {
44835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44836       };
44837     } catch (...) {
44838       {
44839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44840       };
44841     }
44842   }
44843 }
44844
44845
44846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44847   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44848
44849   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44850   {
44851     try {
44852       (arg1)->clear();
44853     } catch (std::out_of_range& e) {
44854       {
44855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44856       };
44857     } catch (std::exception& e) {
44858       {
44859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44860       };
44861     } catch (...) {
44862       {
44863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44864       };
44865     }
44866   }
44867 }
44868
44869
44870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44871   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44872   Dali::TouchPoint *arg2 = 0 ;
44873
44874   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44875   arg2 = (Dali::TouchPoint *)jarg2;
44876   if (!arg2) {
44877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44878     return ;
44879   }
44880   {
44881     try {
44882       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44883     } catch (std::out_of_range& e) {
44884       {
44885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44886       };
44887     } catch (std::exception& e) {
44888       {
44889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44890       };
44891     } catch (...) {
44892       {
44893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44894       };
44895     }
44896   }
44897 }
44898
44899
44900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44901   unsigned long jresult ;
44902   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44903   std::vector< Dali::TouchPoint >::size_type result;
44904
44905   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44906   {
44907     try {
44908       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44916       };
44917     } catch (...) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44920       };
44921     }
44922   }
44923   jresult = (unsigned long)result;
44924   return jresult;
44925 }
44926
44927
44928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44929   unsigned long jresult ;
44930   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44931   std::vector< Dali::TouchPoint >::size_type result;
44932
44933   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44934   {
44935     try {
44936       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44937     } catch (std::out_of_range& e) {
44938       {
44939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44940       };
44941     } catch (std::exception& e) {
44942       {
44943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44944       };
44945     } catch (...) {
44946       {
44947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44948       };
44949     }
44950   }
44951   jresult = (unsigned long)result;
44952   return jresult;
44953 }
44954
44955
44956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44958   std::vector< Dali::TouchPoint >::size_type arg2 ;
44959
44960   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44961   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44962   {
44963     try {
44964       (arg1)->reserve(arg2);
44965     } catch (std::out_of_range& e) {
44966       {
44967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44968       };
44969     } catch (std::exception& e) {
44970       {
44971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44972       };
44973     } catch (...) {
44974       {
44975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44976       };
44977     }
44978   }
44979 }
44980
44981
44982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44983   void * jresult ;
44984   std::vector< Dali::TouchPoint > *result = 0 ;
44985
44986   {
44987     try {
44988       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45000       };
45001     }
45002   }
45003   jresult = (void *)result;
45004   return jresult;
45005 }
45006
45007
45008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45009   void * jresult ;
45010   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45011   std::vector< Dali::TouchPoint > *result = 0 ;
45012
45013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45014   if (!arg1) {
45015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45016     return 0;
45017   }
45018   {
45019     try {
45020       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45021     } catch (std::out_of_range& e) {
45022       {
45023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (std::exception& e) {
45026       {
45027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45028       };
45029     } catch (...) {
45030       {
45031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45032       };
45033     }
45034   }
45035   jresult = (void *)result;
45036   return jresult;
45037 }
45038
45039
45040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45041   void * jresult ;
45042   int arg1 ;
45043   std::vector< Dali::TouchPoint > *result = 0 ;
45044
45045   arg1 = (int)jarg1;
45046   {
45047     try {
45048       try {
45049         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45050       }
45051       catch(std::out_of_range &_e) {
45052         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45053         return 0;
45054       }
45055
45056     } catch (std::out_of_range& e) {
45057       {
45058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45059       };
45060     } catch (std::exception& e) {
45061       {
45062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45063       };
45064     } catch (...) {
45065       {
45066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45067       };
45068     }
45069   }
45070   jresult = (void *)result;
45071   return jresult;
45072 }
45073
45074
45075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45076   void * jresult ;
45077   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45078   int arg2 ;
45079   SwigValueWrapper< Dali::TouchPoint > result;
45080
45081   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45082   arg2 = (int)jarg2;
45083   {
45084     try {
45085       try {
45086         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45087       }
45088       catch(std::out_of_range &_e) {
45089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45090         return 0;
45091       }
45092
45093     } catch (std::out_of_range& e) {
45094       {
45095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45096       };
45097     } catch (std::exception& e) {
45098       {
45099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45100       };
45101     } catch (...) {
45102       {
45103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45104       };
45105     }
45106   }
45107   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45108   return jresult;
45109 }
45110
45111
45112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45113   void * jresult ;
45114   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45115   int arg2 ;
45116   Dali::TouchPoint *result = 0 ;
45117
45118   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45119   arg2 = (int)jarg2;
45120   {
45121     try {
45122       try {
45123         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45124       }
45125       catch(std::out_of_range &_e) {
45126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45127         return 0;
45128       }
45129
45130     } catch (std::out_of_range& e) {
45131       {
45132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45133       };
45134     } catch (std::exception& e) {
45135       {
45136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45137       };
45138     } catch (...) {
45139       {
45140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45141       };
45142     }
45143   }
45144   jresult = (void *)result;
45145   return jresult;
45146 }
45147
45148
45149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45150   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45151   int arg2 ;
45152   Dali::TouchPoint *arg3 = 0 ;
45153
45154   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45155   arg2 = (int)jarg2;
45156   arg3 = (Dali::TouchPoint *)jarg3;
45157   if (!arg3) {
45158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45159     return ;
45160   }
45161   {
45162     try {
45163       try {
45164         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45165       }
45166       catch(std::out_of_range &_e) {
45167         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45168         return ;
45169       }
45170
45171     } catch (std::out_of_range& e) {
45172       {
45173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45174       };
45175     } catch (std::exception& e) {
45176       {
45177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45178       };
45179     } catch (...) {
45180       {
45181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45182       };
45183     }
45184   }
45185 }
45186
45187
45188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45189   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45190   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45191
45192   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45193   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45194   if (!arg2) {
45195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45196     return ;
45197   }
45198   {
45199     try {
45200       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45201     } catch (std::out_of_range& e) {
45202       {
45203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45204       };
45205     } catch (std::exception& e) {
45206       {
45207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45212       };
45213     }
45214   }
45215 }
45216
45217
45218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45219   void * jresult ;
45220   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45221   int arg2 ;
45222   int arg3 ;
45223   std::vector< Dali::TouchPoint > *result = 0 ;
45224
45225   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45226   arg2 = (int)jarg2;
45227   arg3 = (int)jarg3;
45228   {
45229     try {
45230       try {
45231         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45232       }
45233       catch(std::out_of_range &_e) {
45234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45235         return 0;
45236       }
45237       catch(std::invalid_argument &_e) {
45238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45239         return 0;
45240       }
45241
45242     } catch (std::out_of_range& e) {
45243       {
45244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (std::exception& e) {
45247       {
45248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45249       };
45250     } catch (...) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45253       };
45254     }
45255   }
45256   jresult = (void *)result;
45257   return jresult;
45258 }
45259
45260
45261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45262   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45263   int arg2 ;
45264   Dali::TouchPoint *arg3 = 0 ;
45265
45266   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45267   arg2 = (int)jarg2;
45268   arg3 = (Dali::TouchPoint *)jarg3;
45269   if (!arg3) {
45270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45271     return ;
45272   }
45273   {
45274     try {
45275       try {
45276         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45277       }
45278       catch(std::out_of_range &_e) {
45279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45280         return ;
45281       }
45282
45283     } catch (std::out_of_range& e) {
45284       {
45285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45286       };
45287     } catch (std::exception& e) {
45288       {
45289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45290       };
45291     } catch (...) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45294       };
45295     }
45296   }
45297 }
45298
45299
45300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45301   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45302   int arg2 ;
45303   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45304
45305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45306   arg2 = (int)jarg2;
45307   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45308   if (!arg3) {
45309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45310     return ;
45311   }
45312   {
45313     try {
45314       try {
45315         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45316       }
45317       catch(std::out_of_range &_e) {
45318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45319         return ;
45320       }
45321
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45333       };
45334     }
45335   }
45336 }
45337
45338
45339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45340   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45341   int arg2 ;
45342
45343   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45344   arg2 = (int)jarg2;
45345   {
45346     try {
45347       try {
45348         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45349       }
45350       catch(std::out_of_range &_e) {
45351         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45352         return ;
45353       }
45354
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (...) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45366       };
45367     }
45368   }
45369 }
45370
45371
45372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45373   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45374   int arg2 ;
45375   int arg3 ;
45376
45377   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45378   arg2 = (int)jarg2;
45379   arg3 = (int)jarg3;
45380   {
45381     try {
45382       try {
45383         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45384       }
45385       catch(std::out_of_range &_e) {
45386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45387         return ;
45388       }
45389       catch(std::invalid_argument &_e) {
45390         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45391         return ;
45392       }
45393
45394     } catch (std::out_of_range& e) {
45395       {
45396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45397       };
45398     } catch (std::exception& e) {
45399       {
45400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45405       };
45406     }
45407   }
45408 }
45409
45410
45411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45412   void * jresult ;
45413   Dali::TouchPoint *arg1 = 0 ;
45414   int arg2 ;
45415   std::vector< Dali::TouchPoint > *result = 0 ;
45416
45417   arg1 = (Dali::TouchPoint *)jarg1;
45418   if (!arg1) {
45419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45420     return 0;
45421   }
45422   arg2 = (int)jarg2;
45423   {
45424     try {
45425       try {
45426         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45427       }
45428       catch(std::out_of_range &_e) {
45429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45430         return 0;
45431       }
45432
45433     } catch (std::out_of_range& e) {
45434       {
45435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (std::exception& e) {
45438       {
45439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447   jresult = (void *)result;
45448   return jresult;
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45454
45455   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45456   {
45457     try {
45458       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45459     } catch (std::out_of_range& e) {
45460       {
45461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45462       };
45463     } catch (std::exception& e) {
45464       {
45465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45466       };
45467     } catch (...) {
45468       {
45469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45470       };
45471     }
45472   }
45473 }
45474
45475
45476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45477   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45478   int arg2 ;
45479   int arg3 ;
45480
45481   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45482   arg2 = (int)jarg2;
45483   arg3 = (int)jarg3;
45484   {
45485     try {
45486       try {
45487         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45488       }
45489       catch(std::out_of_range &_e) {
45490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45491         return ;
45492       }
45493       catch(std::invalid_argument &_e) {
45494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45495         return ;
45496       }
45497
45498     } catch (std::out_of_range& e) {
45499       {
45500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45501       };
45502     } catch (std::exception& e) {
45503       {
45504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45505       };
45506     } catch (...) {
45507       {
45508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45509       };
45510     }
45511   }
45512 }
45513
45514
45515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45516   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45517   int arg2 ;
45518   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45519
45520   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45521   arg2 = (int)jarg2;
45522   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45523   if (!arg3) {
45524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45525     return ;
45526   }
45527   {
45528     try {
45529       try {
45530         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45531       }
45532       catch(std::out_of_range &_e) {
45533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45534         return ;
45535       }
45536
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45548       };
45549     }
45550   }
45551 }
45552
45553
45554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45555   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45556
45557   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45558   {
45559     try {
45560       delete arg1;
45561     } catch (std::out_of_range& e) {
45562       {
45563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45564       };
45565     } catch (std::exception& e) {
45566       {
45567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45568       };
45569     } catch (...) {
45570       {
45571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45572       };
45573     }
45574   }
45575 }
45576
45577
45578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45579   void * jresult ;
45580   Dali::Rect< int > *result = 0 ;
45581
45582   {
45583     try {
45584       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45585     } catch (std::out_of_range& e) {
45586       {
45587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45588       };
45589     } catch (std::exception& e) {
45590       {
45591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45592       };
45593     } catch (...) {
45594       {
45595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45596       };
45597     }
45598   }
45599   jresult = (void *)result;
45600   return jresult;
45601 }
45602
45603
45604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45605   void * jresult ;
45606   int arg1 ;
45607   int arg2 ;
45608   int arg3 ;
45609   int arg4 ;
45610   Dali::Rect< int > *result = 0 ;
45611
45612   arg1 = (int)jarg1;
45613   arg2 = (int)jarg2;
45614   arg3 = (int)jarg3;
45615   arg4 = (int)jarg4;
45616   {
45617     try {
45618       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45619     } catch (std::out_of_range& e) {
45620       {
45621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45622       };
45623     } catch (std::exception& e) {
45624       {
45625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45626       };
45627     } catch (...) {
45628       {
45629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45630       };
45631     }
45632   }
45633   jresult = (void *)result;
45634   return jresult;
45635 }
45636
45637
45638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45639   void * jresult ;
45640   Dali::Rect< int > *arg1 = 0 ;
45641   Dali::Rect< int > *result = 0 ;
45642
45643   arg1 = (Dali::Rect< int > *)jarg1;
45644   if (!arg1) {
45645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45646     return 0;
45647   }
45648   {
45649     try {
45650       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45651     } catch (std::out_of_range& e) {
45652       {
45653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45654       };
45655     } catch (std::exception& e) {
45656       {
45657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45658       };
45659     } catch (...) {
45660       {
45661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45662       };
45663     }
45664   }
45665   jresult = (void *)result;
45666   return jresult;
45667 }
45668
45669
45670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45671   void * jresult ;
45672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45673   Dali::Rect< int > *arg2 = 0 ;
45674   Dali::Rect< int > *result = 0 ;
45675
45676   arg1 = (Dali::Rect< int > *)jarg1;
45677   arg2 = (Dali::Rect< int > *)jarg2;
45678   if (!arg2) {
45679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45680     return 0;
45681   }
45682   {
45683     try {
45684       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45685     } catch (std::out_of_range& e) {
45686       {
45687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (std::exception& e) {
45690       {
45691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (...) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45696       };
45697     }
45698   }
45699   jresult = (void *)result;
45700   return jresult;
45701 }
45702
45703
45704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45705   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45706   int arg2 ;
45707   int arg3 ;
45708   int arg4 ;
45709   int arg5 ;
45710
45711   arg1 = (Dali::Rect< int > *)jarg1;
45712   arg2 = (int)jarg2;
45713   arg3 = (int)jarg3;
45714   arg4 = (int)jarg4;
45715   arg5 = (int)jarg5;
45716   {
45717     try {
45718       (arg1)->Set(arg2,arg3,arg4,arg5);
45719     } catch (std::out_of_range& e) {
45720       {
45721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45722       };
45723     } catch (std::exception& e) {
45724       {
45725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45726       };
45727     } catch (...) {
45728       {
45729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45730       };
45731     }
45732   }
45733 }
45734
45735
45736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45737   unsigned int jresult ;
45738   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45739   bool result;
45740
45741   arg1 = (Dali::Rect< int > *)jarg1;
45742   {
45743     try {
45744       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45745     } catch (std::out_of_range& e) {
45746       {
45747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45748       };
45749     } catch (std::exception& e) {
45750       {
45751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45752       };
45753     } catch (...) {
45754       {
45755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45756       };
45757     }
45758   }
45759   jresult = result;
45760   return jresult;
45761 }
45762
45763
45764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45765   int jresult ;
45766   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45767   int result;
45768
45769   arg1 = (Dali::Rect< int > *)jarg1;
45770   {
45771     try {
45772       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45773     } catch (std::out_of_range& e) {
45774       {
45775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45776       };
45777     } catch (std::exception& e) {
45778       {
45779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45780       };
45781     } catch (...) {
45782       {
45783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45784       };
45785     }
45786   }
45787   jresult = result;
45788   return jresult;
45789 }
45790
45791
45792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45793   int jresult ;
45794   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45795   int result;
45796
45797   arg1 = (Dali::Rect< int > *)jarg1;
45798   {
45799     try {
45800       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45801     } catch (std::out_of_range& e) {
45802       {
45803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45804       };
45805     } catch (std::exception& e) {
45806       {
45807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45808       };
45809     } catch (...) {
45810       {
45811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45812       };
45813     }
45814   }
45815   jresult = result;
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45821   int jresult ;
45822   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45823   int result;
45824
45825   arg1 = (Dali::Rect< int > *)jarg1;
45826   {
45827     try {
45828       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45829     } catch (std::out_of_range& e) {
45830       {
45831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (std::exception& e) {
45834       {
45835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45836       };
45837     } catch (...) {
45838       {
45839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45840       };
45841     }
45842   }
45843   jresult = result;
45844   return jresult;
45845 }
45846
45847
45848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45849   int jresult ;
45850   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45851   int result;
45852
45853   arg1 = (Dali::Rect< int > *)jarg1;
45854   {
45855     try {
45856       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45857     } catch (std::out_of_range& e) {
45858       {
45859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (std::exception& e) {
45862       {
45863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45864       };
45865     } catch (...) {
45866       {
45867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45868       };
45869     }
45870   }
45871   jresult = result;
45872   return jresult;
45873 }
45874
45875
45876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45877   int jresult ;
45878   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45879   int result;
45880
45881   arg1 = (Dali::Rect< int > *)jarg1;
45882   {
45883     try {
45884       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45885     } catch (std::out_of_range& e) {
45886       {
45887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (std::exception& e) {
45890       {
45891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45892       };
45893     } catch (...) {
45894       {
45895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45896       };
45897     }
45898   }
45899   jresult = result;
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45905   unsigned int jresult ;
45906   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45907   Dali::Rect< int > *arg2 = 0 ;
45908   bool result;
45909
45910   arg1 = (Dali::Rect< int > *)jarg1;
45911   arg2 = (Dali::Rect< int > *)jarg2;
45912   if (!arg2) {
45913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45914     return 0;
45915   }
45916   {
45917     try {
45918       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45919     } catch (std::out_of_range& e) {
45920       {
45921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45922       };
45923     } catch (std::exception& e) {
45924       {
45925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45926       };
45927     } catch (...) {
45928       {
45929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45930       };
45931     }
45932   }
45933   jresult = result;
45934   return jresult;
45935 }
45936
45937
45938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45939   unsigned int jresult ;
45940   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45941   Dali::Rect< int > *arg2 = 0 ;
45942   bool result;
45943
45944   arg1 = (Dali::Rect< int > *)jarg1;
45945   arg2 = (Dali::Rect< int > *)jarg2;
45946   if (!arg2) {
45947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45948     return 0;
45949   }
45950   {
45951     try {
45952       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45953     } catch (std::out_of_range& e) {
45954       {
45955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45956       };
45957     } catch (std::exception& e) {
45958       {
45959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45960       };
45961     } catch (...) {
45962       {
45963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45964       };
45965     }
45966   }
45967   jresult = result;
45968   return jresult;
45969 }
45970
45971
45972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45973   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45974   int arg2 ;
45975
45976   arg1 = (Dali::Rect< int > *)jarg1;
45977   arg2 = (int)jarg2;
45978   if (arg1) (arg1)->x = arg2;
45979 }
45980
45981
45982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45983   int jresult ;
45984   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45985   int result;
45986
45987   arg1 = (Dali::Rect< int > *)jarg1;
45988   result = (int) ((arg1)->x);
45989   jresult = result;
45990   return jresult;
45991 }
45992
45993
45994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45995   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45996   int arg2 ;
45997
45998   arg1 = (Dali::Rect< int > *)jarg1;
45999   arg2 = (int)jarg2;
46000   if (arg1) (arg1)->left = arg2;
46001 }
46002
46003
46004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46005   int jresult ;
46006   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46007   int result;
46008
46009   arg1 = (Dali::Rect< int > *)jarg1;
46010   result = (int) ((arg1)->left);
46011   jresult = result;
46012   return jresult;
46013 }
46014
46015
46016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46017   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46018   int arg2 ;
46019
46020   arg1 = (Dali::Rect< int > *)jarg1;
46021   arg2 = (int)jarg2;
46022   if (arg1) (arg1)->y = arg2;
46023 }
46024
46025
46026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46027   int jresult ;
46028   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46029   int result;
46030
46031   arg1 = (Dali::Rect< int > *)jarg1;
46032   result = (int) ((arg1)->y);
46033   jresult = result;
46034   return jresult;
46035 }
46036
46037
46038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46039   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46040   int arg2 ;
46041
46042   arg1 = (Dali::Rect< int > *)jarg1;
46043   arg2 = (int)jarg2;
46044   if (arg1) (arg1)->right = arg2;
46045 }
46046
46047
46048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46049   int jresult ;
46050   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46051   int result;
46052
46053   arg1 = (Dali::Rect< int > *)jarg1;
46054   result = (int) ((arg1)->right);
46055   jresult = result;
46056   return jresult;
46057 }
46058
46059
46060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46061   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46062   int arg2 ;
46063
46064   arg1 = (Dali::Rect< int > *)jarg1;
46065   arg2 = (int)jarg2;
46066   if (arg1) (arg1)->width = arg2;
46067 }
46068
46069
46070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46071   int jresult ;
46072   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46073   int result;
46074
46075   arg1 = (Dali::Rect< int > *)jarg1;
46076   result = (int) ((arg1)->width);
46077   jresult = result;
46078   return jresult;
46079 }
46080
46081
46082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46083   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46084   int arg2 ;
46085
46086   arg1 = (Dali::Rect< int > *)jarg1;
46087   arg2 = (int)jarg2;
46088   if (arg1) (arg1)->bottom = arg2;
46089 }
46090
46091
46092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46093   int jresult ;
46094   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46095   int result;
46096
46097   arg1 = (Dali::Rect< int > *)jarg1;
46098   result = (int) ((arg1)->bottom);
46099   jresult = result;
46100   return jresult;
46101 }
46102
46103
46104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46105   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46106   int arg2 ;
46107
46108   arg1 = (Dali::Rect< int > *)jarg1;
46109   arg2 = (int)jarg2;
46110   if (arg1) (arg1)->height = arg2;
46111 }
46112
46113
46114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46115   int jresult ;
46116   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46117   int result;
46118
46119   arg1 = (Dali::Rect< int > *)jarg1;
46120   result = (int) ((arg1)->height);
46121   jresult = result;
46122   return jresult;
46123 }
46124
46125
46126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46127   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46128   int arg2 ;
46129
46130   arg1 = (Dali::Rect< int > *)jarg1;
46131   arg2 = (int)jarg2;
46132   if (arg1) (arg1)->top = arg2;
46133 }
46134
46135
46136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46137   int jresult ;
46138   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46139   int result;
46140
46141   arg1 = (Dali::Rect< int > *)jarg1;
46142   result = (int) ((arg1)->top);
46143   jresult = result;
46144   return jresult;
46145 }
46146
46147
46148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46149   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46150
46151   arg1 = (Dali::Rect< int > *)jarg1;
46152   {
46153     try {
46154       delete arg1;
46155     } catch (std::out_of_range& e) {
46156       {
46157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46158       };
46159     } catch (std::exception& e) {
46160       {
46161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46162       };
46163     } catch (...) {
46164       {
46165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46166       };
46167     }
46168   }
46169 }
46170
46171
46172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46173   void * jresult ;
46174   Dali::Rect< float > *result = 0 ;
46175
46176   {
46177     try {
46178       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46179     } catch (std::out_of_range& e) {
46180       {
46181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (std::exception& e) {
46184       {
46185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (...) {
46188       {
46189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46190       };
46191     }
46192   }
46193   jresult = (void *)result;
46194   return jresult;
46195 }
46196
46197
46198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46199   void * jresult ;
46200   float arg1 ;
46201   float arg2 ;
46202   float arg3 ;
46203   float arg4 ;
46204   Dali::Rect< float > *result = 0 ;
46205
46206   arg1 = (float)jarg1;
46207   arg2 = (float)jarg2;
46208   arg3 = (float)jarg3;
46209   arg4 = (float)jarg4;
46210   {
46211     try {
46212       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46213     } catch (std::out_of_range& e) {
46214       {
46215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46216       };
46217     } catch (std::exception& e) {
46218       {
46219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46220       };
46221     } catch (...) {
46222       {
46223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46224       };
46225     }
46226   }
46227   jresult = (void *)result;
46228   return jresult;
46229 }
46230
46231
46232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46233   void * jresult ;
46234   Dali::Rect< float > *arg1 = 0 ;
46235   Dali::Rect< float > *result = 0 ;
46236
46237   arg1 = (Dali::Rect< float > *)jarg1;
46238   if (!arg1) {
46239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46240     return 0;
46241   }
46242   {
46243     try {
46244       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46245     } catch (std::out_of_range& e) {
46246       {
46247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (std::exception& e) {
46250       {
46251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (...) {
46254       {
46255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46256       };
46257     }
46258   }
46259   jresult = (void *)result;
46260   return jresult;
46261 }
46262
46263
46264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46265   void * jresult ;
46266   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46267   Dali::Rect< float > *arg2 = 0 ;
46268   Dali::Rect< float > *result = 0 ;
46269
46270   arg1 = (Dali::Rect< float > *)jarg1;
46271   arg2 = (Dali::Rect< float > *)jarg2;
46272   if (!arg2) {
46273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46274     return 0;
46275   }
46276   {
46277     try {
46278       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46279     } catch (std::out_of_range& e) {
46280       {
46281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46282       };
46283     } catch (std::exception& e) {
46284       {
46285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46286       };
46287     } catch (...) {
46288       {
46289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46290       };
46291     }
46292   }
46293   jresult = (void *)result;
46294   return jresult;
46295 }
46296
46297
46298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46299   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46300   float arg2 ;
46301   float arg3 ;
46302   float arg4 ;
46303   float arg5 ;
46304
46305   arg1 = (Dali::Rect< float > *)jarg1;
46306   arg2 = (float)jarg2;
46307   arg3 = (float)jarg3;
46308   arg4 = (float)jarg4;
46309   arg5 = (float)jarg5;
46310   {
46311     try {
46312       (arg1)->Set(arg2,arg3,arg4,arg5);
46313     } catch (std::out_of_range& e) {
46314       {
46315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46316       };
46317     } catch (std::exception& e) {
46318       {
46319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46320       };
46321     } catch (...) {
46322       {
46323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46324       };
46325     }
46326   }
46327 }
46328
46329
46330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46331   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46332   float arg2 ;
46333
46334   arg1 = (Dali::Rect< float > *)jarg1;
46335   arg2 = (float)jarg2;
46336   if (arg1) (arg1)->x = arg2;
46337 }
46338
46339
46340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46341   float jresult ;
46342   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46343   float result;
46344
46345   arg1 = (Dali::Rect< float > *)jarg1;
46346   result = (float) ((arg1)->x);
46347   jresult = result;
46348   return jresult;
46349 }
46350
46351
46352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46353   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46354   float arg2 ;
46355
46356   arg1 = (Dali::Rect< float > *)jarg1;
46357   arg2 = (float)jarg2;
46358   if (arg1) (arg1)->left = arg2;
46359 }
46360
46361
46362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46363   float jresult ;
46364   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46365   float result;
46366
46367   arg1 = (Dali::Rect< float > *)jarg1;
46368   result = (float) ((arg1)->left);
46369   jresult = result;
46370   return jresult;
46371 }
46372
46373
46374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46375   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46376   float arg2 ;
46377
46378   arg1 = (Dali::Rect< float > *)jarg1;
46379   arg2 = (float)jarg2;
46380   if (arg1) (arg1)->y = arg2;
46381 }
46382
46383
46384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46385   float jresult ;
46386   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46387   float result;
46388
46389   arg1 = (Dali::Rect< float > *)jarg1;
46390   result = (float) ((arg1)->y);
46391   jresult = result;
46392   return jresult;
46393 }
46394
46395
46396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46397   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46398   float arg2 ;
46399
46400   arg1 = (Dali::Rect< float > *)jarg1;
46401   arg2 = (float)jarg2;
46402   if (arg1) (arg1)->right = arg2;
46403 }
46404
46405
46406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46407   float jresult ;
46408   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46409   float result;
46410
46411   arg1 = (Dali::Rect< float > *)jarg1;
46412   result = (float) ((arg1)->right);
46413   jresult = result;
46414   return jresult;
46415 }
46416
46417
46418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46419   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46420   float arg2 ;
46421
46422   arg1 = (Dali::Rect< float > *)jarg1;
46423   arg2 = (float)jarg2;
46424   if (arg1) (arg1)->width = arg2;
46425 }
46426
46427
46428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46429   float jresult ;
46430   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46431   float result;
46432
46433   arg1 = (Dali::Rect< float > *)jarg1;
46434   result = (float) ((arg1)->width);
46435   jresult = result;
46436   return jresult;
46437 }
46438
46439
46440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46441   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46442   float arg2 ;
46443
46444   arg1 = (Dali::Rect< float > *)jarg1;
46445   arg2 = (float)jarg2;
46446   if (arg1) (arg1)->bottom = arg2;
46447 }
46448
46449
46450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46451   float jresult ;
46452   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46453   float result;
46454
46455   arg1 = (Dali::Rect< float > *)jarg1;
46456   result = (float) ((arg1)->bottom);
46457   jresult = result;
46458   return jresult;
46459 }
46460
46461
46462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46463   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46464   float arg2 ;
46465
46466   arg1 = (Dali::Rect< float > *)jarg1;
46467   arg2 = (float)jarg2;
46468   if (arg1) (arg1)->height = arg2;
46469 }
46470
46471
46472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46473   float jresult ;
46474   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46475   float result;
46476
46477   arg1 = (Dali::Rect< float > *)jarg1;
46478   result = (float) ((arg1)->height);
46479   jresult = result;
46480   return jresult;
46481 }
46482
46483
46484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46485   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46486   float arg2 ;
46487
46488   arg1 = (Dali::Rect< float > *)jarg1;
46489   arg2 = (float)jarg2;
46490   if (arg1) (arg1)->top = arg2;
46491 }
46492
46493
46494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46495   float jresult ;
46496   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46497   float result;
46498
46499   arg1 = (Dali::Rect< float > *)jarg1;
46500   result = (float) ((arg1)->top);
46501   jresult = result;
46502   return jresult;
46503 }
46504
46505
46506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46507   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46508
46509   arg1 = (Dali::Rect< float > *)jarg1;
46510   {
46511     try {
46512       delete arg1;
46513     } catch (std::out_of_range& e) {
46514       {
46515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46516       };
46517     } catch (std::exception& e) {
46518       {
46519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46520       };
46521     } catch (...) {
46522       {
46523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46524       };
46525     }
46526   }
46527 }
46528
46529
46530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46531   int jresult ;
46532   int result;
46533
46534   result = (int)Dali::Vector< int >::BaseType;
46535   jresult = (int)result;
46536   return jresult;
46537 }
46538
46539
46540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46541   void * jresult ;
46542   Dali::Vector< int > *result = 0 ;
46543
46544   {
46545     try {
46546       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46547     } catch (std::out_of_range& e) {
46548       {
46549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46550       };
46551     } catch (std::exception& e) {
46552       {
46553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46554       };
46555     } catch (...) {
46556       {
46557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46558       };
46559     }
46560   }
46561   jresult = (void *)result;
46562   return jresult;
46563 }
46564
46565
46566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46567   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46568
46569   arg1 = (Dali::Vector< int > *)jarg1;
46570   {
46571     try {
46572       delete arg1;
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46580       };
46581     } catch (...) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46584       };
46585     }
46586   }
46587 }
46588
46589
46590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46591   void * jresult ;
46592   Dali::Vector< int > *arg1 = 0 ;
46593   Dali::Vector< int > *result = 0 ;
46594
46595   arg1 = (Dali::Vector< int > *)jarg1;
46596   if (!arg1) {
46597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46598     return 0;
46599   }
46600   {
46601     try {
46602       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46603     } catch (std::out_of_range& e) {
46604       {
46605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (std::exception& e) {
46608       {
46609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617   jresult = (void *)result;
46618   return jresult;
46619 }
46620
46621
46622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46623   void * jresult ;
46624   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46625   Dali::Vector< int > *arg2 = 0 ;
46626   Dali::Vector< int > *result = 0 ;
46627
46628   arg1 = (Dali::Vector< int > *)jarg1;
46629   arg2 = (Dali::Vector< int > *)jarg2;
46630   if (!arg2) {
46631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46632     return 0;
46633   }
46634   {
46635     try {
46636       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46637     } catch (std::out_of_range& e) {
46638       {
46639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46640       };
46641     } catch (std::exception& e) {
46642       {
46643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46644       };
46645     } catch (...) {
46646       {
46647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46648       };
46649     }
46650   }
46651   jresult = (void *)result;
46652   return jresult;
46653 }
46654
46655
46656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46657   void * jresult ;
46658   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46659   Dali::Vector< int >::Iterator result;
46660
46661   arg1 = (Dali::Vector< int > *)jarg1;
46662   {
46663     try {
46664       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46665     } catch (std::out_of_range& e) {
46666       {
46667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46668       };
46669     } catch (std::exception& e) {
46670       {
46671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46672       };
46673     } catch (...) {
46674       {
46675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46676       };
46677     }
46678   }
46679   jresult = (void *)result;
46680   return jresult;
46681 }
46682
46683
46684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46685   void * jresult ;
46686   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46687   Dali::Vector< int >::Iterator result;
46688
46689   arg1 = (Dali::Vector< int > *)jarg1;
46690   {
46691     try {
46692       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46693     } catch (std::out_of_range& e) {
46694       {
46695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (std::exception& e) {
46698       {
46699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (...) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46704       };
46705     }
46706   }
46707   jresult = (void *)result;
46708   return jresult;
46709 }
46710
46711
46712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46713   void * jresult ;
46714   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46715   Dali::Vector< int >::SizeType arg2 ;
46716   Dali::Vector< int >::ItemType *result = 0 ;
46717
46718   arg1 = (Dali::Vector< int > *)jarg1;
46719   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46720   {
46721     try {
46722       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46723     } catch (std::out_of_range& e) {
46724       {
46725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46726       };
46727     } catch (std::exception& e) {
46728       {
46729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46730       };
46731     } catch (...) {
46732       {
46733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46734       };
46735     }
46736   }
46737   jresult = (void *)result;
46738   return jresult;
46739 }
46740
46741
46742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46743   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46744   Dali::Vector< int >::ItemType *arg2 = 0 ;
46745   Dali::Vector< int >::ItemType temp2 ;
46746
46747   arg1 = (Dali::Vector< int > *)jarg1;
46748   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46749   arg2 = &temp2;
46750   {
46751     try {
46752       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46753     } catch (std::out_of_range& e) {
46754       {
46755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46756       };
46757     } catch (std::exception& e) {
46758       {
46759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46760       };
46761     } catch (...) {
46762       {
46763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46764       };
46765     }
46766   }
46767 }
46768
46769
46770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46771   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46772   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46773   Dali::Vector< int >::ItemType *arg3 = 0 ;
46774   Dali::Vector< int >::ItemType temp3 ;
46775
46776   arg1 = (Dali::Vector< int > *)jarg1;
46777   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46778   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46779   arg3 = &temp3;
46780   {
46781     try {
46782       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46783     } catch (std::out_of_range& e) {
46784       {
46785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46786       };
46787     } catch (std::exception& e) {
46788       {
46789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46794       };
46795     }
46796   }
46797 }
46798
46799
46800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46801   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46802   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46803   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46804   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46805
46806   arg1 = (Dali::Vector< int > *)jarg1;
46807   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46808   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46809   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46810   {
46811     try {
46812       (arg1)->Insert(arg2,arg3,arg4);
46813     } catch (std::out_of_range& e) {
46814       {
46815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46816       };
46817     } catch (std::exception& e) {
46818       {
46819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46820       };
46821     } catch (...) {
46822       {
46823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46824       };
46825     }
46826   }
46827 }
46828
46829
46830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46831   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46832   Dali::Vector< int >::SizeType arg2 ;
46833
46834   arg1 = (Dali::Vector< int > *)jarg1;
46835   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46836   {
46837     try {
46838       (arg1)->Reserve(arg2);
46839     } catch (std::out_of_range& e) {
46840       {
46841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46842       };
46843     } catch (std::exception& e) {
46844       {
46845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46846       };
46847     } catch (...) {
46848       {
46849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46850       };
46851     }
46852   }
46853 }
46854
46855
46856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46857   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46858   Dali::Vector< int >::SizeType arg2 ;
46859
46860   arg1 = (Dali::Vector< int > *)jarg1;
46861   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46862   {
46863     try {
46864       (arg1)->Resize(arg2);
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 (...) {
46874       {
46875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46876       };
46877     }
46878   }
46879 }
46880
46881
46882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46883   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46884   Dali::Vector< int >::SizeType arg2 ;
46885   Dali::Vector< int >::ItemType *arg3 = 0 ;
46886   Dali::Vector< int >::ItemType temp3 ;
46887
46888   arg1 = (Dali::Vector< int > *)jarg1;
46889   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46890   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46891   arg3 = &temp3;
46892   {
46893     try {
46894       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46895     } catch (std::out_of_range& e) {
46896       {
46897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46898       };
46899     } catch (std::exception& e) {
46900       {
46901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46902       };
46903     } catch (...) {
46904       {
46905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46906       };
46907     }
46908   }
46909 }
46910
46911
46912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46913   void * jresult ;
46914   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46915   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46916   Dali::Vector< int >::Iterator result;
46917
46918   arg1 = (Dali::Vector< int > *)jarg1;
46919   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46920   {
46921     try {
46922       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46923     } catch (std::out_of_range& e) {
46924       {
46925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46926       };
46927     } catch (std::exception& e) {
46928       {
46929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46930       };
46931     } catch (...) {
46932       {
46933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46934       };
46935     }
46936   }
46937   jresult = (void *)result;
46938   return jresult;
46939 }
46940
46941
46942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46943   void * jresult ;
46944   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46945   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46946   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46947   Dali::Vector< int >::Iterator result;
46948
46949   arg1 = (Dali::Vector< int > *)jarg1;
46950   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46951   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46952   {
46953     try {
46954       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46955     } catch (std::out_of_range& e) {
46956       {
46957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46958       };
46959     } catch (std::exception& e) {
46960       {
46961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46962       };
46963     } catch (...) {
46964       {
46965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46966       };
46967     }
46968   }
46969   jresult = (void *)result;
46970   return jresult;
46971 }
46972
46973
46974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46975   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46976   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46977
46978   arg1 = (Dali::Vector< int > *)jarg1;
46979   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46980   {
46981     try {
46982       (arg1)->Remove(arg2);
46983     } catch (std::out_of_range& e) {
46984       {
46985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46986       };
46987     } catch (std::exception& e) {
46988       {
46989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46990       };
46991     } catch (...) {
46992       {
46993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46994       };
46995     }
46996   }
46997 }
46998
46999
47000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47001   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47002   Dali::Vector< int > *arg2 = 0 ;
47003
47004   arg1 = (Dali::Vector< int > *)jarg1;
47005   arg2 = (Dali::Vector< int > *)jarg2;
47006   if (!arg2) {
47007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47008     return ;
47009   }
47010   {
47011     try {
47012       (arg1)->Swap(*arg2);
47013     } catch (std::out_of_range& e) {
47014       {
47015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47016       };
47017     } catch (std::exception& e) {
47018       {
47019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47020       };
47021     } catch (...) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47024       };
47025     }
47026   }
47027 }
47028
47029
47030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47031   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47032
47033   arg1 = (Dali::Vector< int > *)jarg1;
47034   {
47035     try {
47036       (arg1)->Clear();
47037     } catch (std::out_of_range& e) {
47038       {
47039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47040       };
47041     } catch (std::exception& e) {
47042       {
47043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47044       };
47045     } catch (...) {
47046       {
47047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47048       };
47049     }
47050   }
47051 }
47052
47053
47054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47056
47057   arg1 = (Dali::Vector< int > *)jarg1;
47058   {
47059     try {
47060       (arg1)->Release();
47061     } catch (std::out_of_range& e) {
47062       {
47063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47064       };
47065     } catch (std::exception& e) {
47066       {
47067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47068       };
47069     } catch (...) {
47070       {
47071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47072       };
47073     }
47074   }
47075 }
47076
47077
47078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47079   int jresult ;
47080   int result;
47081
47082   result = (int)Dali::Vector< float >::BaseType;
47083   jresult = (int)result;
47084   return jresult;
47085 }
47086
47087
47088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47089   void * jresult ;
47090   Dali::Vector< float > *result = 0 ;
47091
47092   {
47093     try {
47094       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47095     } catch (std::out_of_range& e) {
47096       {
47097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47098       };
47099     } catch (std::exception& e) {
47100       {
47101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47102       };
47103     } catch (...) {
47104       {
47105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47106       };
47107     }
47108   }
47109   jresult = (void *)result;
47110   return jresult;
47111 }
47112
47113
47114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47115   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47116
47117   arg1 = (Dali::Vector< float > *)jarg1;
47118   {
47119     try {
47120       delete arg1;
47121     } catch (std::out_of_range& e) {
47122       {
47123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (std::exception& e) {
47126       {
47127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47128       };
47129     } catch (...) {
47130       {
47131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47132       };
47133     }
47134   }
47135 }
47136
47137
47138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47139   void * jresult ;
47140   Dali::Vector< float > *arg1 = 0 ;
47141   Dali::Vector< float > *result = 0 ;
47142
47143   arg1 = (Dali::Vector< float > *)jarg1;
47144   if (!arg1) {
47145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47146     return 0;
47147   }
47148   {
47149     try {
47150       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47151     } catch (std::out_of_range& e) {
47152       {
47153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47154       };
47155     } catch (std::exception& e) {
47156       {
47157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47158       };
47159     } catch (...) {
47160       {
47161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47162       };
47163     }
47164   }
47165   jresult = (void *)result;
47166   return jresult;
47167 }
47168
47169
47170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47171   void * jresult ;
47172   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47173   Dali::Vector< float > *arg2 = 0 ;
47174   Dali::Vector< float > *result = 0 ;
47175
47176   arg1 = (Dali::Vector< float > *)jarg1;
47177   arg2 = (Dali::Vector< float > *)jarg2;
47178   if (!arg2) {
47179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47180     return 0;
47181   }
47182   {
47183     try {
47184       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47185     } catch (std::out_of_range& e) {
47186       {
47187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47188       };
47189     } catch (std::exception& e) {
47190       {
47191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47192       };
47193     } catch (...) {
47194       {
47195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47196       };
47197     }
47198   }
47199   jresult = (void *)result;
47200   return jresult;
47201 }
47202
47203
47204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47205   void * jresult ;
47206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47207   Dali::Vector< float >::Iterator result;
47208
47209   arg1 = (Dali::Vector< float > *)jarg1;
47210   {
47211     try {
47212       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47213     } catch (std::out_of_range& e) {
47214       {
47215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (std::exception& e) {
47218       {
47219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47224       };
47225     }
47226   }
47227   jresult = (void *)result;
47228   return jresult;
47229 }
47230
47231
47232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47233   void * jresult ;
47234   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47235   Dali::Vector< float >::Iterator result;
47236
47237   arg1 = (Dali::Vector< float > *)jarg1;
47238   {
47239     try {
47240       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47241     } catch (std::out_of_range& e) {
47242       {
47243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47244       };
47245     } catch (std::exception& e) {
47246       {
47247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47248       };
47249     } catch (...) {
47250       {
47251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47252       };
47253     }
47254   }
47255   jresult = (void *)result;
47256   return jresult;
47257 }
47258
47259
47260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47261   void * jresult ;
47262   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47263   Dali::Vector< float >::SizeType arg2 ;
47264   Dali::Vector< float >::ItemType *result = 0 ;
47265
47266   arg1 = (Dali::Vector< float > *)jarg1;
47267   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47268   {
47269     try {
47270       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47271     } catch (std::out_of_range& e) {
47272       {
47273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47274       };
47275     } catch (std::exception& e) {
47276       {
47277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47278       };
47279     } catch (...) {
47280       {
47281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47282       };
47283     }
47284   }
47285   jresult = (void *)result;
47286   return jresult;
47287 }
47288
47289
47290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47291   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47292   Dali::Vector< float >::ItemType *arg2 = 0 ;
47293   Dali::Vector< float >::ItemType temp2 ;
47294
47295   arg1 = (Dali::Vector< float > *)jarg1;
47296   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47297   arg2 = &temp2;
47298   {
47299     try {
47300       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47301     } catch (std::out_of_range& e) {
47302       {
47303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47304       };
47305     } catch (std::exception& e) {
47306       {
47307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47308       };
47309     } catch (...) {
47310       {
47311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47312       };
47313     }
47314   }
47315 }
47316
47317
47318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47319   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47320   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47321   Dali::Vector< float >::ItemType *arg3 = 0 ;
47322   Dali::Vector< float >::ItemType temp3 ;
47323
47324   arg1 = (Dali::Vector< float > *)jarg1;
47325   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47326   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47327   arg3 = &temp3;
47328   {
47329     try {
47330       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47331     } catch (std::out_of_range& e) {
47332       {
47333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47334       };
47335     } catch (std::exception& e) {
47336       {
47337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47338       };
47339     } catch (...) {
47340       {
47341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47342       };
47343     }
47344   }
47345 }
47346
47347
47348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47349   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47350   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47351   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47352   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47353
47354   arg1 = (Dali::Vector< float > *)jarg1;
47355   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47356   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47357   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47358   {
47359     try {
47360       (arg1)->Insert(arg2,arg3,arg4);
47361     } catch (std::out_of_range& e) {
47362       {
47363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47364       };
47365     } catch (std::exception& e) {
47366       {
47367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47368       };
47369     } catch (...) {
47370       {
47371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47372       };
47373     }
47374   }
47375 }
47376
47377
47378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47379   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47380   Dali::Vector< float >::SizeType arg2 ;
47381
47382   arg1 = (Dali::Vector< float > *)jarg1;
47383   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47384   {
47385     try {
47386       (arg1)->Reserve(arg2);
47387     } catch (std::out_of_range& e) {
47388       {
47389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47390       };
47391     } catch (std::exception& e) {
47392       {
47393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47394       };
47395     } catch (...) {
47396       {
47397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47398       };
47399     }
47400   }
47401 }
47402
47403
47404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47405   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47406   Dali::Vector< float >::SizeType arg2 ;
47407
47408   arg1 = (Dali::Vector< float > *)jarg1;
47409   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47410   {
47411     try {
47412       (arg1)->Resize(arg2);
47413     } catch (std::out_of_range& e) {
47414       {
47415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47416       };
47417     } catch (std::exception& e) {
47418       {
47419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47420       };
47421     } catch (...) {
47422       {
47423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47424       };
47425     }
47426   }
47427 }
47428
47429
47430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47431   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47432   Dali::Vector< float >::SizeType arg2 ;
47433   Dali::Vector< float >::ItemType *arg3 = 0 ;
47434   Dali::Vector< float >::ItemType temp3 ;
47435
47436   arg1 = (Dali::Vector< float > *)jarg1;
47437   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47438   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47439   arg3 = &temp3;
47440   {
47441     try {
47442       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47443     } catch (std::out_of_range& e) {
47444       {
47445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47446       };
47447     } catch (std::exception& e) {
47448       {
47449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47450       };
47451     } catch (...) {
47452       {
47453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47454       };
47455     }
47456   }
47457 }
47458
47459
47460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47461   void * jresult ;
47462   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47463   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47464   Dali::Vector< float >::Iterator result;
47465
47466   arg1 = (Dali::Vector< float > *)jarg1;
47467   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47468   {
47469     try {
47470       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47471     } catch (std::out_of_range& e) {
47472       {
47473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47474       };
47475     } catch (std::exception& e) {
47476       {
47477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47478       };
47479     } catch (...) {
47480       {
47481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47482       };
47483     }
47484   }
47485   jresult = (void *)result;
47486   return jresult;
47487 }
47488
47489
47490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47491   void * jresult ;
47492   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47493   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47494   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47495   Dali::Vector< float >::Iterator result;
47496
47497   arg1 = (Dali::Vector< float > *)jarg1;
47498   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47499   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47500   {
47501     try {
47502       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47503     } catch (std::out_of_range& e) {
47504       {
47505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47506       };
47507     } catch (std::exception& e) {
47508       {
47509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47510       };
47511     } catch (...) {
47512       {
47513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47514       };
47515     }
47516   }
47517   jresult = (void *)result;
47518   return jresult;
47519 }
47520
47521
47522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47523   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47524   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47525
47526   arg1 = (Dali::Vector< float > *)jarg1;
47527   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47528   {
47529     try {
47530       (arg1)->Remove(arg2);
47531     } catch (std::out_of_range& e) {
47532       {
47533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47534       };
47535     } catch (std::exception& e) {
47536       {
47537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47538       };
47539     } catch (...) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47542       };
47543     }
47544   }
47545 }
47546
47547
47548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47549   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47550   Dali::Vector< float > *arg2 = 0 ;
47551
47552   arg1 = (Dali::Vector< float > *)jarg1;
47553   arg2 = (Dali::Vector< float > *)jarg2;
47554   if (!arg2) {
47555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47556     return ;
47557   }
47558   {
47559     try {
47560       (arg1)->Swap(*arg2);
47561     } catch (std::out_of_range& e) {
47562       {
47563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47564       };
47565     } catch (std::exception& e) {
47566       {
47567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47568       };
47569     } catch (...) {
47570       {
47571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47572       };
47573     }
47574   }
47575 }
47576
47577
47578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47579   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47580
47581   arg1 = (Dali::Vector< float > *)jarg1;
47582   {
47583     try {
47584       (arg1)->Clear();
47585     } catch (std::out_of_range& e) {
47586       {
47587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47588       };
47589     } catch (std::exception& e) {
47590       {
47591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47592       };
47593     } catch (...) {
47594       {
47595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47596       };
47597     }
47598   }
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47603   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47604
47605   arg1 = (Dali::Vector< float > *)jarg1;
47606   {
47607     try {
47608       (arg1)->Release();
47609     } catch (std::out_of_range& e) {
47610       {
47611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47612       };
47613     } catch (std::exception& e) {
47614       {
47615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47616       };
47617     } catch (...) {
47618       {
47619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47620       };
47621     }
47622   }
47623 }
47624
47625
47626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47627   int jresult ;
47628   int result;
47629
47630   result = (int)Dali::Vector< unsigned char >::BaseType;
47631   jresult = (int)result;
47632   return jresult;
47633 }
47634
47635
47636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47637   void * jresult ;
47638   Dali::Vector< unsigned char > *result = 0 ;
47639
47640   {
47641     try {
47642       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47643     } catch (std::out_of_range& e) {
47644       {
47645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47646       };
47647     } catch (std::exception& e) {
47648       {
47649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47650       };
47651     } catch (...) {
47652       {
47653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47654       };
47655     }
47656   }
47657   jresult = (void *)result;
47658   return jresult;
47659 }
47660
47661
47662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47663   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47664
47665   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47666   {
47667     try {
47668       delete arg1;
47669     } catch (std::out_of_range& e) {
47670       {
47671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47672       };
47673     } catch (std::exception& e) {
47674       {
47675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47676       };
47677     } catch (...) {
47678       {
47679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47680       };
47681     }
47682   }
47683 }
47684
47685
47686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47687   void * jresult ;
47688   Dali::Vector< unsigned char > *arg1 = 0 ;
47689   Dali::Vector< unsigned char > *result = 0 ;
47690
47691   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47692   if (!arg1) {
47693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47694     return 0;
47695   }
47696   {
47697     try {
47698       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47699     } catch (std::out_of_range& e) {
47700       {
47701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47702       };
47703     } catch (std::exception& e) {
47704       {
47705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (...) {
47708       {
47709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47710       };
47711     }
47712   }
47713   jresult = (void *)result;
47714   return jresult;
47715 }
47716
47717
47718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47719   void * jresult ;
47720   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47721   Dali::Vector< unsigned char > *arg2 = 0 ;
47722   Dali::Vector< unsigned char > *result = 0 ;
47723
47724   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47725   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47726   if (!arg2) {
47727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47728     return 0;
47729   }
47730   {
47731     try {
47732       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47733     } catch (std::out_of_range& e) {
47734       {
47735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47736       };
47737     } catch (std::exception& e) {
47738       {
47739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47740       };
47741     } catch (...) {
47742       {
47743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47744       };
47745     }
47746   }
47747   jresult = (void *)result;
47748   return jresult;
47749 }
47750
47751
47752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47753   void * jresult ;
47754   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47755   Dali::Vector< unsigned char >::Iterator result;
47756
47757   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47758   {
47759     try {
47760       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47761     } catch (std::out_of_range& e) {
47762       {
47763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47764       };
47765     } catch (std::exception& e) {
47766       {
47767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47768       };
47769     } catch (...) {
47770       {
47771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47772       };
47773     }
47774   }
47775   jresult = (void *)result;
47776   return jresult;
47777 }
47778
47779
47780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47781   void * jresult ;
47782   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47783   Dali::Vector< unsigned char >::Iterator result;
47784
47785   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47786   {
47787     try {
47788       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47789     } catch (std::out_of_range& e) {
47790       {
47791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47792       };
47793     } catch (std::exception& e) {
47794       {
47795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47796       };
47797     } catch (...) {
47798       {
47799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47800       };
47801     }
47802   }
47803   jresult = (void *)result;
47804   return jresult;
47805 }
47806
47807
47808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47809   void * jresult ;
47810   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47811   Dali::Vector< unsigned char >::SizeType arg2 ;
47812   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47813
47814   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47815   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47816   {
47817     try {
47818       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47819     } catch (std::out_of_range& e) {
47820       {
47821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47822       };
47823     } catch (std::exception& e) {
47824       {
47825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47826       };
47827     } catch (...) {
47828       {
47829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47830       };
47831     }
47832   }
47833   jresult = (void *)result;
47834   return jresult;
47835 }
47836
47837
47838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47839   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47840   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47841   Dali::Vector< unsigned char >::ItemType temp2 ;
47842
47843   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47844   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47845   arg2 = &temp2;
47846   {
47847     try {
47848       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47856       };
47857     } catch (...) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47860       };
47861     }
47862   }
47863 }
47864
47865
47866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47867   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47868   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47869   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47870   Dali::Vector< unsigned char >::ItemType temp3 ;
47871
47872   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47873   arg2 = jarg2;
47874   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47875   arg3 = &temp3;
47876   {
47877     try {
47878       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47879     } catch (std::out_of_range& e) {
47880       {
47881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47882       };
47883     } catch (std::exception& e) {
47884       {
47885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47886       };
47887     } catch (...) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47890       };
47891     }
47892   }
47893
47894
47895 }
47896
47897
47898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47899   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47900   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47901   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47902   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47903
47904   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47905   arg2 = jarg2;
47906   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47907   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47908   {
47909     try {
47910       (arg1)->Insert(arg2,arg3,arg4);
47911     } catch (std::out_of_range& e) {
47912       {
47913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47914       };
47915     } catch (std::exception& e) {
47916       {
47917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47918       };
47919     } catch (...) {
47920       {
47921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47922       };
47923     }
47924   }
47925
47926
47927 }
47928
47929
47930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47931   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47932   Dali::Vector< unsigned char >::SizeType arg2 ;
47933
47934   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47935   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47936   {
47937     try {
47938       (arg1)->Reserve(arg2);
47939     } catch (std::out_of_range& e) {
47940       {
47941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47942       };
47943     } catch (std::exception& e) {
47944       {
47945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47946       };
47947     } catch (...) {
47948       {
47949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47950       };
47951     }
47952   }
47953 }
47954
47955
47956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47957   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47958   Dali::Vector< unsigned char >::SizeType arg2 ;
47959
47960   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47961   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47962   {
47963     try {
47964       (arg1)->Resize(arg2);
47965     } catch (std::out_of_range& e) {
47966       {
47967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47968       };
47969     } catch (std::exception& e) {
47970       {
47971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47972       };
47973     } catch (...) {
47974       {
47975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47976       };
47977     }
47978   }
47979 }
47980
47981
47982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47983   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47984   Dali::Vector< unsigned char >::SizeType arg2 ;
47985   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47986   Dali::Vector< unsigned char >::ItemType temp3 ;
47987
47988   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47989   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47990   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47991   arg3 = &temp3;
47992   {
47993     try {
47994       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47995     } catch (std::out_of_range& e) {
47996       {
47997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (std::exception& e) {
48000       {
48001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48002       };
48003     } catch (...) {
48004       {
48005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48006       };
48007     }
48008   }
48009 }
48010
48011
48012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48013   void * jresult ;
48014   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48015   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48016   Dali::Vector< unsigned char >::Iterator result;
48017
48018   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48019   arg2 = jarg2;
48020   {
48021     try {
48022       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48023     } catch (std::out_of_range& e) {
48024       {
48025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48026       };
48027     } catch (std::exception& e) {
48028       {
48029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48030       };
48031     } catch (...) {
48032       {
48033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48034       };
48035     }
48036   }
48037   jresult = (void *)result;
48038
48039
48040   return jresult;
48041 }
48042
48043
48044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48045   void * jresult ;
48046   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48047   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48048   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48049   Dali::Vector< unsigned char >::Iterator result;
48050
48051   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48052   arg2 = jarg2;
48053   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48054   {
48055     try {
48056       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48057     } catch (std::out_of_range& e) {
48058       {
48059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48060       };
48061     } catch (std::exception& e) {
48062       {
48063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48064       };
48065     } catch (...) {
48066       {
48067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48068       };
48069     }
48070   }
48071   jresult = (void *)result;
48072
48073
48074   return jresult;
48075 }
48076
48077
48078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48079   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48080   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48081
48082   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48083   arg2 = jarg2;
48084   {
48085     try {
48086       (arg1)->Remove(arg2);
48087     } catch (std::out_of_range& e) {
48088       {
48089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48090       };
48091     } catch (std::exception& e) {
48092       {
48093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48094       };
48095     } catch (...) {
48096       {
48097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48098       };
48099     }
48100   }
48101
48102
48103 }
48104
48105
48106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48107   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48108   Dali::Vector< unsigned char > *arg2 = 0 ;
48109
48110   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48111   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48112   if (!arg2) {
48113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48114     return ;
48115   }
48116   {
48117     try {
48118       (arg1)->Swap(*arg2);
48119     } catch (std::out_of_range& e) {
48120       {
48121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48122       };
48123     } catch (std::exception& e) {
48124       {
48125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (...) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48130       };
48131     }
48132   }
48133 }
48134
48135
48136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48137   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48138
48139   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48140   {
48141     try {
48142       (arg1)->Clear();
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48150       };
48151     } catch (...) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48154       };
48155     }
48156   }
48157 }
48158
48159
48160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48161   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48162
48163   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48164   {
48165     try {
48166       (arg1)->Release();
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (...) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48178       };
48179     }
48180   }
48181 }
48182
48183
48184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48185   int jresult ;
48186   int result;
48187
48188   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48189   jresult = (int)result;
48190   return jresult;
48191 }
48192
48193
48194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48195   void * jresult ;
48196   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48197
48198   {
48199     try {
48200       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48201     } catch (std::out_of_range& e) {
48202       {
48203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48204       };
48205     } catch (std::exception& e) {
48206       {
48207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48208       };
48209     } catch (...) {
48210       {
48211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48212       };
48213     }
48214   }
48215   jresult = (void *)result;
48216   return jresult;
48217 }
48218
48219
48220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48221   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48222
48223   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48224   {
48225     try {
48226       delete arg1;
48227     } catch (std::out_of_range& e) {
48228       {
48229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (std::exception& e) {
48232       {
48233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48234       };
48235     } catch (...) {
48236       {
48237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48238       };
48239     }
48240   }
48241 }
48242
48243
48244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48245   void * jresult ;
48246   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48247   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48248
48249   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48250   if (!arg1) {
48251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48252     return 0;
48253   }
48254   {
48255     try {
48256       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48257     } catch (std::out_of_range& e) {
48258       {
48259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48260       };
48261     } catch (std::exception& e) {
48262       {
48263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48264       };
48265     } catch (...) {
48266       {
48267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48268       };
48269     }
48270   }
48271   jresult = (void *)result;
48272   return jresult;
48273 }
48274
48275
48276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48277   void * jresult ;
48278   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48279   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48280   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48281
48282   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48283   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48284   if (!arg2) {
48285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48286     return 0;
48287   }
48288   {
48289     try {
48290       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48291     } catch (std::out_of_range& e) {
48292       {
48293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48294       };
48295     } catch (std::exception& e) {
48296       {
48297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48298       };
48299     } catch (...) {
48300       {
48301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48302       };
48303     }
48304   }
48305   jresult = (void *)result;
48306   return jresult;
48307 }
48308
48309
48310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48311   void * jresult ;
48312   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48313   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48314
48315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48316   {
48317     try {
48318       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48319     } catch (std::out_of_range& e) {
48320       {
48321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48322       };
48323     } catch (std::exception& e) {
48324       {
48325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48326       };
48327     } catch (...) {
48328       {
48329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48330       };
48331     }
48332   }
48333   jresult = (void *)result;
48334   return jresult;
48335 }
48336
48337
48338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48339   void * jresult ;
48340   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48341   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48342
48343   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48344   {
48345     try {
48346       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48347     } catch (std::out_of_range& e) {
48348       {
48349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48350       };
48351     } catch (std::exception& e) {
48352       {
48353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48354       };
48355     } catch (...) {
48356       {
48357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48358       };
48359     }
48360   }
48361   jresult = (void *)result;
48362   return jresult;
48363 }
48364
48365
48366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48367   void * jresult ;
48368   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48369   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48370   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48371
48372   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48373   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48374   {
48375     try {
48376       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48377     } catch (std::out_of_range& e) {
48378       {
48379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48380       };
48381     } catch (std::exception& e) {
48382       {
48383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48384       };
48385     } catch (...) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48388       };
48389     }
48390   }
48391   jresult = (void *)result;
48392   return jresult;
48393 }
48394
48395
48396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48397   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48398   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48399
48400   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48401   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48402   if (!arg2) {
48403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48404     return ;
48405   }
48406   {
48407     try {
48408       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48409     } catch (std::out_of_range& e) {
48410       {
48411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48412       };
48413     } catch (std::exception& e) {
48414       {
48415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48416       };
48417     } catch (...) {
48418       {
48419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48420       };
48421     }
48422   }
48423 }
48424
48425
48426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48427   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48428   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48429   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48430
48431   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48432   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48433   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48434   if (!arg3) {
48435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48436     return ;
48437   }
48438   {
48439     try {
48440       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48441     } catch (std::out_of_range& e) {
48442       {
48443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48444       };
48445     } catch (std::exception& e) {
48446       {
48447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48448       };
48449     } catch (...) {
48450       {
48451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48452       };
48453     }
48454   }
48455 }
48456
48457
48458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48459   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48460   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48461   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48462   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48463
48464   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48465   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48466   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48467   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48468   {
48469     try {
48470       (arg1)->Insert(arg2,arg3,arg4);
48471     } catch (std::out_of_range& e) {
48472       {
48473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48474       };
48475     } catch (std::exception& e) {
48476       {
48477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48478       };
48479     } catch (...) {
48480       {
48481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48482       };
48483     }
48484   }
48485 }
48486
48487
48488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48489   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48490   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48491
48492   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48493   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48494   {
48495     try {
48496       (arg1)->Reserve(arg2);
48497     } catch (std::out_of_range& e) {
48498       {
48499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48500       };
48501     } catch (std::exception& e) {
48502       {
48503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48504       };
48505     } catch (...) {
48506       {
48507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48508       };
48509     }
48510   }
48511 }
48512
48513
48514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48515   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48516   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48517
48518   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48519   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48520   {
48521     try {
48522       (arg1)->Resize(arg2);
48523     } catch (std::out_of_range& e) {
48524       {
48525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48526       };
48527     } catch (std::exception& e) {
48528       {
48529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48530       };
48531     } catch (...) {
48532       {
48533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48534       };
48535     }
48536   }
48537 }
48538
48539
48540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48541   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48542   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48543   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48544
48545   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48546   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48547   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48548   if (!arg3) {
48549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48550     return ;
48551   }
48552   {
48553     try {
48554       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48555     } catch (std::out_of_range& e) {
48556       {
48557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (std::exception& e) {
48560       {
48561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48562       };
48563     } catch (...) {
48564       {
48565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48566       };
48567     }
48568   }
48569 }
48570
48571
48572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48573   void * jresult ;
48574   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48575   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48576   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48577
48578   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48579   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48580   {
48581     try {
48582       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48583     } catch (std::out_of_range& e) {
48584       {
48585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (std::exception& e) {
48588       {
48589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48590       };
48591     } catch (...) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48594       };
48595     }
48596   }
48597   jresult = (void *)result;
48598   return jresult;
48599 }
48600
48601
48602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48603   void * jresult ;
48604   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48605   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48606   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48607   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48608
48609   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48610   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48611   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48612   {
48613     try {
48614       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48615     } catch (std::out_of_range& e) {
48616       {
48617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48618       };
48619     } catch (std::exception& e) {
48620       {
48621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (...) {
48624       {
48625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48626       };
48627     }
48628   }
48629   jresult = (void *)result;
48630   return jresult;
48631 }
48632
48633
48634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48635   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48636   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48637
48638   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48639   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48640   {
48641     try {
48642       (arg1)->Remove(arg2);
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48650       };
48651     } catch (...) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48654       };
48655     }
48656   }
48657 }
48658
48659
48660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48661   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48662   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48663
48664   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48665   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48666   if (!arg2) {
48667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48668     return ;
48669   }
48670   {
48671     try {
48672       (arg1)->Swap(*arg2);
48673     } catch (std::out_of_range& e) {
48674       {
48675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48676       };
48677     } catch (std::exception& e) {
48678       {
48679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48680       };
48681     } catch (...) {
48682       {
48683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48684       };
48685     }
48686   }
48687 }
48688
48689
48690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48691   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48692
48693   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48694   {
48695     try {
48696       (arg1)->Clear();
48697     } catch (std::out_of_range& e) {
48698       {
48699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48700       };
48701     } catch (std::exception& e) {
48702       {
48703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (...) {
48706       {
48707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48708       };
48709     }
48710   }
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48715   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48716
48717   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48718   {
48719     try {
48720       (arg1)->Release();
48721     } catch (std::out_of_range& e) {
48722       {
48723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48724       };
48725     } catch (std::exception& e) {
48726       {
48727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48728       };
48729     } catch (...) {
48730       {
48731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48732       };
48733     }
48734   }
48735 }
48736
48737
48738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48739   void * jresult ;
48740   Dali::Signal< void () > *result = 0 ;
48741
48742   {
48743     try {
48744       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48745     } catch (std::out_of_range& e) {
48746       {
48747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48748       };
48749     } catch (std::exception& e) {
48750       {
48751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48752       };
48753     } catch (...) {
48754       {
48755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48756       };
48757     }
48758   }
48759   jresult = (void *)result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48765   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48766
48767   arg1 = (Dali::Signal< void () > *)jarg1;
48768   {
48769     try {
48770       delete arg1;
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48778       };
48779     } catch (...) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48782       };
48783     }
48784   }
48785 }
48786
48787
48788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48789   unsigned int jresult ;
48790   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48791   bool result;
48792
48793   arg1 = (Dali::Signal< void () > *)jarg1;
48794   {
48795     try {
48796       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48797     } catch (std::out_of_range& e) {
48798       {
48799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48800       };
48801     } catch (std::exception& e) {
48802       {
48803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48804       };
48805     } catch (...) {
48806       {
48807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48808       };
48809     }
48810   }
48811   jresult = result;
48812   return jresult;
48813 }
48814
48815
48816 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48817   unsigned long jresult ;
48818   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48819   std::size_t result;
48820
48821   arg1 = (Dali::Signal< void () > *)jarg1;
48822   {
48823     try {
48824       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48825     } catch (std::out_of_range& e) {
48826       {
48827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (std::exception& e) {
48830       {
48831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48836       };
48837     }
48838   }
48839   jresult = (unsigned long)result;
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48845   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48846   void (*arg2)() = (void (*)()) 0 ;
48847
48848   arg1 = (Dali::Signal< void () > *)jarg1;
48849   arg2 = (void (*)())jarg2;
48850   {
48851     try {
48852       (arg1)->Connect(arg2);
48853     } catch (std::out_of_range& e) {
48854       {
48855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48856       };
48857     } catch (std::exception& e) {
48858       {
48859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48860       };
48861     } catch (...) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48864       };
48865     }
48866   }
48867 }
48868
48869
48870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48871   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48872   void (*arg2)() = (void (*)()) 0 ;
48873
48874   arg1 = (Dali::Signal< void () > *)jarg1;
48875   arg2 = (void (*)())jarg2;
48876   {
48877     try {
48878       (arg1)->Disconnect(arg2);
48879     } catch (std::out_of_range& e) {
48880       {
48881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (std::exception& e) {
48884       {
48885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48886       };
48887     } catch (...) {
48888       {
48889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48890       };
48891     }
48892   }
48893 }
48894
48895
48896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48897   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48898   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48899   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48900
48901   arg1 = (Dali::Signal< void () > *)jarg1;
48902   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48903   arg3 = (Dali::FunctorDelegate *)jarg3;
48904   {
48905     try {
48906       (arg1)->Connect(arg2,arg3);
48907     } catch (std::out_of_range& e) {
48908       {
48909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48910       };
48911     } catch (std::exception& e) {
48912       {
48913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (...) {
48916       {
48917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48918       };
48919     }
48920   }
48921 }
48922
48923
48924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48925   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48926
48927   arg1 = (Dali::Signal< void () > *)jarg1;
48928   {
48929     try {
48930       (arg1)->Emit();
48931     } catch (std::out_of_range& e) {
48932       {
48933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48934       };
48935     } catch (std::exception& e) {
48936       {
48937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48938       };
48939     } catch (...) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48942       };
48943     }
48944   }
48945 }
48946
48947
48948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48949   unsigned int jresult ;
48950   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48951   bool result;
48952
48953   arg1 = (Dali::Signal< void (float) > *)jarg1;
48954   {
48955     try {
48956       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48957     } catch (std::out_of_range& e) {
48958       {
48959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48960       };
48961     } catch (std::exception& e) {
48962       {
48963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48964       };
48965     } catch (...) {
48966       {
48967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48968       };
48969     }
48970   }
48971   jresult = result;
48972   return jresult;
48973 }
48974
48975
48976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48977   unsigned long jresult ;
48978   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48979   std::size_t result;
48980
48981   arg1 = (Dali::Signal< void (float) > *)jarg1;
48982   {
48983     try {
48984       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48985     } catch (std::out_of_range& e) {
48986       {
48987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48988       };
48989     } catch (std::exception& e) {
48990       {
48991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48992       };
48993     } catch (...) {
48994       {
48995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48996       };
48997     }
48998   }
48999   jresult = (unsigned long)result;
49000   return jresult;
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49005   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49006   void (*arg2)(float) = (void (*)(float)) 0 ;
49007
49008   arg1 = (Dali::Signal< void (float) > *)jarg1;
49009   arg2 = (void (*)(float))jarg2;
49010   {
49011     try {
49012       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49013     } catch (std::out_of_range& e) {
49014       {
49015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49016       };
49017     } catch (std::exception& e) {
49018       {
49019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49020       };
49021     } catch (...) {
49022       {
49023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49024       };
49025     }
49026   }
49027 }
49028
49029
49030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49031   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49032   void (*arg2)(float) = (void (*)(float)) 0 ;
49033
49034   arg1 = (Dali::Signal< void (float) > *)jarg1;
49035   arg2 = (void (*)(float))jarg2;
49036   {
49037     try {
49038       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49039     } catch (std::out_of_range& e) {
49040       {
49041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49042       };
49043     } catch (std::exception& e) {
49044       {
49045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49046       };
49047     } catch (...) {
49048       {
49049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49050       };
49051     }
49052   }
49053 }
49054
49055
49056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49057   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49058   float arg2 ;
49059
49060   arg1 = (Dali::Signal< void (float) > *)jarg1;
49061   arg2 = (float)jarg2;
49062   {
49063     try {
49064       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49072       };
49073     } catch (...) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49076       };
49077     }
49078   }
49079 }
49080
49081
49082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49083   void * jresult ;
49084   Dali::Signal< void (float) > *result = 0 ;
49085
49086   {
49087     try {
49088       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49089     } catch (std::out_of_range& e) {
49090       {
49091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49092       };
49093     } catch (std::exception& e) {
49094       {
49095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49096       };
49097     } catch (...) {
49098       {
49099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49100       };
49101     }
49102   }
49103   jresult = (void *)result;
49104   return jresult;
49105 }
49106
49107
49108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49109   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49110
49111   arg1 = (Dali::Signal< void (float) > *)jarg1;
49112   {
49113     try {
49114       delete arg1;
49115     } catch (std::out_of_range& e) {
49116       {
49117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49118       };
49119     } catch (std::exception& e) {
49120       {
49121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49122       };
49123     } catch (...) {
49124       {
49125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49126       };
49127     }
49128   }
49129 }
49130
49131
49132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49133   unsigned int jresult ;
49134   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49135   bool result;
49136
49137   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49138   {
49139     try {
49140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49141     } catch (std::out_of_range& e) {
49142       {
49143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49144       };
49145     } catch (std::exception& e) {
49146       {
49147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49148       };
49149     } catch (...) {
49150       {
49151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49152       };
49153     }
49154   }
49155   jresult = result;
49156   return jresult;
49157 }
49158
49159
49160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49161   unsigned long jresult ;
49162   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49163   std::size_t result;
49164
49165   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49166   {
49167     try {
49168       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49169     } catch (std::out_of_range& e) {
49170       {
49171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (std::exception& e) {
49174       {
49175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49180       };
49181     }
49182   }
49183   jresult = (unsigned long)result;
49184   return jresult;
49185 }
49186
49187
49188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49189   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49190   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49191
49192   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49193   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49194   {
49195     try {
49196       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49197     } catch (std::out_of_range& e) {
49198       {
49199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49200       };
49201     } catch (std::exception& e) {
49202       {
49203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49204       };
49205     } catch (...) {
49206       {
49207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49208       };
49209     }
49210   }
49211 }
49212
49213
49214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49215   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49216   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49217
49218   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49219   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49220   {
49221     try {
49222       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49223     } catch (std::out_of_range& e) {
49224       {
49225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49226       };
49227     } catch (std::exception& e) {
49228       {
49229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49230       };
49231     } catch (...) {
49232       {
49233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49234       };
49235     }
49236   }
49237 }
49238
49239
49240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49241   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49242   Dali::BaseHandle arg2 ;
49243   Dali::BaseHandle *argp2 ;
49244
49245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49246   argp2 = (Dali::BaseHandle *)jarg2;
49247   if (!argp2) {
49248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49249     return ;
49250   }
49251   arg2 = *argp2;
49252   {
49253     try {
49254       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49255     } catch (std::out_of_range& e) {
49256       {
49257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49258       };
49259     } catch (std::exception& e) {
49260       {
49261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49262       };
49263     } catch (...) {
49264       {
49265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49266       };
49267     }
49268   }
49269 }
49270
49271
49272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49273   void * jresult ;
49274   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49275
49276   {
49277     try {
49278       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49279     } catch (std::out_of_range& e) {
49280       {
49281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49282       };
49283     } catch (std::exception& e) {
49284       {
49285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49286       };
49287     } catch (...) {
49288       {
49289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49290       };
49291     }
49292   }
49293   jresult = (void *)result;
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49299   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49300
49301   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49302   {
49303     try {
49304       delete arg1;
49305     } catch (std::out_of_range& e) {
49306       {
49307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49308       };
49309     } catch (std::exception& e) {
49310       {
49311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49312       };
49313     } catch (...) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49316       };
49317     }
49318   }
49319 }
49320
49321
49322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49323   unsigned int jresult ;
49324   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49325   bool result;
49326
49327   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49328   {
49329     try {
49330       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49331     } catch (std::out_of_range& e) {
49332       {
49333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49334       };
49335     } catch (std::exception& e) {
49336       {
49337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49338       };
49339     } catch (...) {
49340       {
49341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49342       };
49343     }
49344   }
49345   jresult = result;
49346   return jresult;
49347 }
49348
49349
49350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49351   unsigned long jresult ;
49352   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49353   std::size_t result;
49354
49355   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49356   {
49357     try {
49358       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49359     } catch (std::out_of_range& e) {
49360       {
49361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (std::exception& e) {
49364       {
49365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49366       };
49367     } catch (...) {
49368       {
49369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49370       };
49371     }
49372   }
49373   jresult = (unsigned long)result;
49374   return jresult;
49375 }
49376
49377
49378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49379   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49380   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49381
49382   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49383   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49384   {
49385     try {
49386       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49387     } catch (std::out_of_range& e) {
49388       {
49389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49390       };
49391     } catch (std::exception& e) {
49392       {
49393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49394       };
49395     } catch (...) {
49396       {
49397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49398       };
49399     }
49400   }
49401 }
49402
49403
49404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49405   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49406   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49407
49408   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49409   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49410   {
49411     try {
49412       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49413     } catch (std::out_of_range& e) {
49414       {
49415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49416       };
49417     } catch (std::exception& e) {
49418       {
49419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49424       };
49425     }
49426   }
49427 }
49428
49429
49430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49431   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49432   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49433
49434   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49435   arg2 = (Dali::RefObject *)jarg2;
49436   {
49437     try {
49438       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49439     } catch (std::out_of_range& e) {
49440       {
49441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49442       };
49443     } catch (std::exception& e) {
49444       {
49445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49446       };
49447     } catch (...) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49450       };
49451     }
49452   }
49453 }
49454
49455
49456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49457   void * jresult ;
49458   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49459
49460   {
49461     try {
49462       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49463     } catch (std::out_of_range& e) {
49464       {
49465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (std::exception& e) {
49468       {
49469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477   jresult = (void *)result;
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49483   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49484
49485   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49486   {
49487     try {
49488       delete arg1;
49489     } catch (std::out_of_range& e) {
49490       {
49491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49492       };
49493     } catch (std::exception& e) {
49494       {
49495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49496       };
49497     } catch (...) {
49498       {
49499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49500       };
49501     }
49502   }
49503 }
49504
49505
49506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49507   unsigned int jresult ;
49508   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49509   bool result;
49510
49511   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49512   {
49513     try {
49514       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49515     } catch (std::out_of_range& e) {
49516       {
49517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49518       };
49519     } catch (std::exception& e) {
49520       {
49521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49522       };
49523     } catch (...) {
49524       {
49525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49526       };
49527     }
49528   }
49529   jresult = result;
49530   return jresult;
49531 }
49532
49533
49534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49535   unsigned long jresult ;
49536   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49537   std::size_t result;
49538
49539   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49540   {
49541     try {
49542       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49554       };
49555     }
49556   }
49557   jresult = (unsigned long)result;
49558   return jresult;
49559 }
49560
49561
49562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49563   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49564   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49565
49566   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49567   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49568   {
49569     try {
49570       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49571     } catch (std::out_of_range& e) {
49572       {
49573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49574       };
49575     } catch (std::exception& e) {
49576       {
49577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49578       };
49579     } catch (...) {
49580       {
49581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49582       };
49583     }
49584   }
49585 }
49586
49587
49588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49589   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49590   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49591
49592   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49593   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49594   {
49595     try {
49596       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49597     } catch (std::out_of_range& e) {
49598       {
49599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49600       };
49601     } catch (std::exception& e) {
49602       {
49603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49604       };
49605     } catch (...) {
49606       {
49607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49608       };
49609     }
49610   }
49611 }
49612
49613
49614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49615   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49616   Dali::PropertyNotification *arg2 = 0 ;
49617
49618   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49619   arg2 = (Dali::PropertyNotification *)jarg2;
49620   if (!arg2) {
49621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49622     return ;
49623   }
49624   {
49625     try {
49626       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49627     } catch (std::out_of_range& e) {
49628       {
49629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49630       };
49631     } catch (std::exception& e) {
49632       {
49633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49634       };
49635     } catch (...) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49638       };
49639     }
49640   }
49641 }
49642
49643
49644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49645   void * jresult ;
49646   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49647
49648   {
49649     try {
49650       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49651     } catch (std::out_of_range& e) {
49652       {
49653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49654       };
49655     } catch (std::exception& e) {
49656       {
49657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49658       };
49659     } catch (...) {
49660       {
49661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49662       };
49663     }
49664   }
49665   jresult = (void *)result;
49666   return jresult;
49667 }
49668
49669
49670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49671   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49672
49673   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49674   {
49675     try {
49676       delete arg1;
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691 }
49692
49693
49694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49695   unsigned int jresult ;
49696   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49697   bool result;
49698
49699   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49700   {
49701     try {
49702       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49703     } catch (std::out_of_range& e) {
49704       {
49705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49706       };
49707     } catch (std::exception& e) {
49708       {
49709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49710       };
49711     } catch (...) {
49712       {
49713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49714       };
49715     }
49716   }
49717   jresult = result;
49718   return jresult;
49719 }
49720
49721
49722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49723   unsigned long jresult ;
49724   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49725   std::size_t result;
49726
49727   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49728   {
49729     try {
49730       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49731     } catch (std::out_of_range& e) {
49732       {
49733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (std::exception& e) {
49736       {
49737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (...) {
49740       {
49741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49742       };
49743     }
49744   }
49745   jresult = (unsigned long)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49751   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49752   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49753
49754   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49755   arg2 = (void (*)(Dali::Image))jarg2;
49756   {
49757     try {
49758       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49759     } catch (std::out_of_range& e) {
49760       {
49761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (std::exception& e) {
49764       {
49765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773 }
49774
49775
49776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49777   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49778   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49779
49780   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49781   arg2 = (void (*)(Dali::Image))jarg2;
49782   {
49783     try {
49784       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49785     } catch (std::out_of_range& e) {
49786       {
49787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49788       };
49789     } catch (std::exception& e) {
49790       {
49791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (...) {
49794       {
49795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49796       };
49797     }
49798   }
49799 }
49800
49801
49802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49803   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49804   Dali::Image arg2 ;
49805   Dali::Image *argp2 ;
49806
49807   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49808   argp2 = (Dali::Image *)jarg2;
49809   if (!argp2) {
49810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49811     return ;
49812   }
49813   arg2 = *argp2;
49814   {
49815     try {
49816       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49817     } catch (std::out_of_range& e) {
49818       {
49819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49820       };
49821     } catch (std::exception& e) {
49822       {
49823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49824       };
49825     } catch (...) {
49826       {
49827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49828       };
49829     }
49830   }
49831 }
49832
49833
49834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49835   void * jresult ;
49836   Dali::Signal< void (Dali::Image) > *result = 0 ;
49837
49838   {
49839     try {
49840       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49841     } catch (std::out_of_range& e) {
49842       {
49843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49844       };
49845     } catch (std::exception& e) {
49846       {
49847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49848       };
49849     } catch (...) {
49850       {
49851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49852       };
49853     }
49854   }
49855   jresult = (void *)result;
49856   return jresult;
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49861   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49862
49863   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49864   {
49865     try {
49866       delete arg1;
49867     } catch (std::out_of_range& e) {
49868       {
49869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49870       };
49871     } catch (std::exception& e) {
49872       {
49873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (...) {
49876       {
49877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49878       };
49879     }
49880   }
49881 }
49882
49883
49884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49885   void * jresult ;
49886   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49887
49888   {
49889     try {
49890       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49891     } catch (std::out_of_range& e) {
49892       {
49893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49894       };
49895     } catch (std::exception& e) {
49896       {
49897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49898       };
49899     } catch (...) {
49900       {
49901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49902       };
49903     }
49904   }
49905   jresult = (void *)result;
49906   return jresult;
49907 }
49908
49909
49910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49911   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49912
49913   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49914   {
49915     try {
49916       delete arg1;
49917     } catch (std::out_of_range& e) {
49918       {
49919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (std::exception& e) {
49922       {
49923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (...) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49928       };
49929     }
49930   }
49931 }
49932
49933
49934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49935   unsigned int jresult ;
49936   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49937   bool result;
49938
49939   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49940   {
49941     try {
49942       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);
49943     } catch (std::out_of_range& e) {
49944       {
49945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49946       };
49947     } catch (std::exception& e) {
49948       {
49949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49950       };
49951     } catch (...) {
49952       {
49953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49954       };
49955     }
49956   }
49957   jresult = result;
49958   return jresult;
49959 }
49960
49961
49962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49963   unsigned long jresult ;
49964   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49965   std::size_t result;
49966
49967   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49968   {
49969     try {
49970       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);
49971     } catch (std::out_of_range& e) {
49972       {
49973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (std::exception& e) {
49976       {
49977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49982       };
49983     }
49984   }
49985   jresult = (unsigned long)result;
49986   return jresult;
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49991   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49992   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49993
49994   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49995   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49996   {
49997     try {
49998       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49999     } catch (std::out_of_range& e) {
50000       {
50001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50002       };
50003     } catch (std::exception& e) {
50004       {
50005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50006       };
50007     } catch (...) {
50008       {
50009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50010       };
50011     }
50012   }
50013 }
50014
50015
50016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50017   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50018   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50019
50020   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50021   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50022   {
50023     try {
50024       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50025     } catch (std::out_of_range& e) {
50026       {
50027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50028       };
50029     } catch (std::exception& e) {
50030       {
50031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50032       };
50033     } catch (...) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50036       };
50037     }
50038   }
50039 }
50040
50041
50042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50043   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50044   Dali::Actor arg2 ;
50045   Dali::LongPressGesture *arg3 = 0 ;
50046   Dali::Actor *argp2 ;
50047
50048   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50049   argp2 = (Dali::Actor *)jarg2;
50050   if (!argp2) {
50051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50052     return ;
50053   }
50054   arg2 = *argp2;
50055   arg3 = (Dali::LongPressGesture *)jarg3;
50056   if (!arg3) {
50057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50058     return ;
50059   }
50060   {
50061     try {
50062       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50063     } catch (std::out_of_range& e) {
50064       {
50065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50066       };
50067     } catch (std::exception& e) {
50068       {
50069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50070       };
50071     } catch (...) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50074       };
50075     }
50076   }
50077 }
50078
50079
50080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50081   void * jresult ;
50082   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50083
50084   {
50085     try {
50086       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50087     } catch (std::out_of_range& e) {
50088       {
50089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50090       };
50091     } catch (std::exception& e) {
50092       {
50093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50094       };
50095     } catch (...) {
50096       {
50097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50098       };
50099     }
50100   }
50101   jresult = (void *)result;
50102   return jresult;
50103 }
50104
50105
50106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50107   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50108
50109   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50110   {
50111     try {
50112       delete arg1;
50113     } catch (std::out_of_range& e) {
50114       {
50115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50116       };
50117     } catch (std::exception& e) {
50118       {
50119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50120       };
50121     } catch (...) {
50122       {
50123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50124       };
50125     }
50126   }
50127 }
50128
50129
50130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50131   unsigned int jresult ;
50132   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50133   bool result;
50134
50135   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50136   {
50137     try {
50138       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);
50139     } catch (std::out_of_range& e) {
50140       {
50141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (std::exception& e) {
50144       {
50145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50146       };
50147     } catch (...) {
50148       {
50149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50150       };
50151     }
50152   }
50153   jresult = result;
50154   return jresult;
50155 }
50156
50157
50158 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50159   unsigned long jresult ;
50160   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50161   std::size_t result;
50162
50163   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50164   {
50165     try {
50166       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);
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (...) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50178       };
50179     }
50180   }
50181   jresult = (unsigned long)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50187   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50188   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50189
50190   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50191   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50192   {
50193     try {
50194       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50195     } catch (std::out_of_range& e) {
50196       {
50197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50198       };
50199     } catch (std::exception& e) {
50200       {
50201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50202       };
50203     } catch (...) {
50204       {
50205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50206       };
50207     }
50208   }
50209 }
50210
50211
50212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50213   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50214   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50215
50216   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50217   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50218   {
50219     try {
50220       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50221     } catch (std::out_of_range& e) {
50222       {
50223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50224       };
50225     } catch (std::exception& e) {
50226       {
50227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50228       };
50229     } catch (...) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50232       };
50233     }
50234   }
50235 }
50236
50237
50238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50239   unsigned int jresult ;
50240   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50241   Dali::Actor arg2 ;
50242   Dali::TouchData *arg3 = 0 ;
50243   Dali::Actor *argp2 ;
50244   bool result;
50245
50246   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50247   argp2 = (Dali::Actor *)jarg2;
50248   if (!argp2) {
50249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50250     return 0;
50251   }
50252   arg2 = *argp2;
50253   arg3 = (Dali::TouchData *)jarg3;
50254   if (!arg3) {
50255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50256     return 0;
50257   }
50258   {
50259     try {
50260       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50261     } catch (std::out_of_range& e) {
50262       {
50263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50264       };
50265     } catch (std::exception& e) {
50266       {
50267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50272       };
50273     }
50274   }
50275   jresult = result;
50276   return jresult;
50277 }
50278
50279
50280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50281   void * jresult ;
50282   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50283
50284   {
50285     try {
50286       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50287     } catch (std::out_of_range& e) {
50288       {
50289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50290       };
50291     } catch (std::exception& e) {
50292       {
50293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50294       };
50295     } catch (...) {
50296       {
50297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50298       };
50299     }
50300   }
50301   jresult = (void *)result;
50302   return jresult;
50303 }
50304
50305
50306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50307   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50308
50309   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50310   {
50311     try {
50312       delete arg1;
50313     } catch (std::out_of_range& e) {
50314       {
50315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50316       };
50317     } catch (std::exception& e) {
50318       {
50319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50320       };
50321     } catch (...) {
50322       {
50323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50324       };
50325     }
50326   }
50327 }
50328
50329
50330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50331   unsigned int jresult ;
50332   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50333   bool result;
50334
50335   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50336   {
50337     try {
50338       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);
50339     } catch (std::out_of_range& e) {
50340       {
50341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50342       };
50343     } catch (std::exception& e) {
50344       {
50345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50346       };
50347     } catch (...) {
50348       {
50349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50350       };
50351     }
50352   }
50353   jresult = result;
50354   return jresult;
50355 }
50356
50357
50358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50359   unsigned long jresult ;
50360   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50361   std::size_t result;
50362
50363   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50364   {
50365     try {
50366       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);
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381   jresult = (unsigned long)result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50387   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50388   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50389
50390   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50391   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50392   {
50393     try {
50394       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50395     } catch (std::out_of_range& e) {
50396       {
50397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50398       };
50399     } catch (std::exception& e) {
50400       {
50401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50402       };
50403     } catch (...) {
50404       {
50405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50406       };
50407     }
50408   }
50409 }
50410
50411
50412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50413   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50414   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50415
50416   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50417   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50418   {
50419     try {
50420       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50421     } catch (std::out_of_range& e) {
50422       {
50423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50424       };
50425     } catch (std::exception& e) {
50426       {
50427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50428       };
50429     } catch (...) {
50430       {
50431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50432       };
50433     }
50434   }
50435 }
50436
50437
50438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50439   unsigned int jresult ;
50440   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50441   Dali::Actor arg2 ;
50442   Dali::HoverEvent *arg3 = 0 ;
50443   Dali::Actor *argp2 ;
50444   bool result;
50445
50446   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50447   argp2 = (Dali::Actor *)jarg2;
50448   if (!argp2) {
50449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50450     return 0;
50451   }
50452   arg2 = *argp2;
50453   arg3 = (Dali::HoverEvent *)jarg3;
50454   if (!arg3) {
50455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50456     return 0;
50457   }
50458   {
50459     try {
50460       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50461     } catch (std::out_of_range& e) {
50462       {
50463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50464       };
50465     } catch (std::exception& e) {
50466       {
50467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50468       };
50469     } catch (...) {
50470       {
50471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50472       };
50473     }
50474   }
50475   jresult = result;
50476   return jresult;
50477 }
50478
50479
50480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50481   void * jresult ;
50482   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50483
50484   {
50485     try {
50486       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50487     } catch (std::out_of_range& e) {
50488       {
50489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50490       };
50491     } catch (std::exception& e) {
50492       {
50493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50494       };
50495     } catch (...) {
50496       {
50497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50498       };
50499     }
50500   }
50501   jresult = (void *)result;
50502   return jresult;
50503 }
50504
50505
50506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50507   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50508
50509   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50510   {
50511     try {
50512       delete arg1;
50513     } catch (std::out_of_range& e) {
50514       {
50515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50516       };
50517     } catch (std::exception& e) {
50518       {
50519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50520       };
50521     } catch (...) {
50522       {
50523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50524       };
50525     }
50526   }
50527 }
50528
50529
50530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50531   unsigned int jresult ;
50532   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50533   bool result;
50534
50535   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50536   {
50537     try {
50538       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);
50539     } catch (std::out_of_range& e) {
50540       {
50541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50542       };
50543     } catch (std::exception& e) {
50544       {
50545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50546       };
50547     } catch (...) {
50548       {
50549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50550       };
50551     }
50552   }
50553   jresult = result;
50554   return jresult;
50555 }
50556
50557
50558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50559   unsigned long jresult ;
50560   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50561   std::size_t result;
50562
50563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50564   {
50565     try {
50566       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);
50567     } catch (std::out_of_range& e) {
50568       {
50569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (std::exception& e) {
50572       {
50573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (...) {
50576       {
50577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50578       };
50579     }
50580   }
50581   jresult = (unsigned long)result;
50582   return jresult;
50583 }
50584
50585
50586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50587   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50588   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50589
50590   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50591   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50592   {
50593     try {
50594       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50595     } catch (std::out_of_range& e) {
50596       {
50597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50598       };
50599     } catch (std::exception& e) {
50600       {
50601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50602       };
50603     } catch (...) {
50604       {
50605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50606       };
50607     }
50608   }
50609 }
50610
50611
50612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50613   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50614   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50615
50616   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50617   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50618   {
50619     try {
50620       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50621     } catch (std::out_of_range& e) {
50622       {
50623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50624       };
50625     } catch (std::exception& e) {
50626       {
50627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50628       };
50629     } catch (...) {
50630       {
50631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50632       };
50633     }
50634   }
50635 }
50636
50637
50638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50639   unsigned int jresult ;
50640   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50641   Dali::Actor arg2 ;
50642   Dali::WheelEvent *arg3 = 0 ;
50643   Dali::Actor *argp2 ;
50644   bool result;
50645
50646   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50647   argp2 = (Dali::Actor *)jarg2;
50648   if (!argp2) {
50649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50650     return 0;
50651   }
50652   arg2 = *argp2;
50653   arg3 = (Dali::WheelEvent *)jarg3;
50654   if (!arg3) {
50655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50656     return 0;
50657   }
50658   {
50659     try {
50660       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50661     } catch (std::out_of_range& e) {
50662       {
50663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50664       };
50665     } catch (std::exception& e) {
50666       {
50667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50668       };
50669     } catch (...) {
50670       {
50671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50672       };
50673     }
50674   }
50675   jresult = result;
50676   return jresult;
50677 }
50678
50679
50680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50681   void * jresult ;
50682   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50683
50684   {
50685     try {
50686       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50687     } catch (std::out_of_range& e) {
50688       {
50689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50690       };
50691     } catch (std::exception& e) {
50692       {
50693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50694       };
50695     } catch (...) {
50696       {
50697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50698       };
50699     }
50700   }
50701   jresult = (void *)result;
50702   return jresult;
50703 }
50704
50705
50706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50707   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50708
50709   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50710   {
50711     try {
50712       delete arg1;
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50720       };
50721     } catch (...) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50724       };
50725     }
50726   }
50727 }
50728
50729
50730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50731   unsigned int jresult ;
50732   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50733   bool result;
50734
50735   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50736   {
50737     try {
50738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50739     } catch (std::out_of_range& e) {
50740       {
50741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50742       };
50743     } catch (std::exception& e) {
50744       {
50745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50746       };
50747     } catch (...) {
50748       {
50749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50750       };
50751     }
50752   }
50753   jresult = result;
50754   return jresult;
50755 }
50756
50757
50758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50759   unsigned long jresult ;
50760   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50761   std::size_t result;
50762
50763   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50764   {
50765     try {
50766       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (...) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50778       };
50779     }
50780   }
50781   jresult = (unsigned long)result;
50782   return jresult;
50783 }
50784
50785
50786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50787   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50788   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50789
50790   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50791   arg2 = (void (*)(Dali::Actor))jarg2;
50792   {
50793     try {
50794       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50795     } catch (std::out_of_range& e) {
50796       {
50797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50798       };
50799     } catch (std::exception& e) {
50800       {
50801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50802       };
50803     } catch (...) {
50804       {
50805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50806       };
50807     }
50808   }
50809 }
50810
50811
50812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50813   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50814   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50815
50816   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50817   arg2 = (void (*)(Dali::Actor))jarg2;
50818   {
50819     try {
50820       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
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 (...) {
50830       {
50831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50832       };
50833     }
50834   }
50835 }
50836
50837
50838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50839   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50840   Dali::Actor arg2 ;
50841   Dali::Actor *argp2 ;
50842
50843   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50844   argp2 = (Dali::Actor *)jarg2;
50845   if (!argp2) {
50846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50847     return ;
50848   }
50849   arg2 = *argp2;
50850   {
50851     try {
50852       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50853     } catch (std::out_of_range& e) {
50854       {
50855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50856       };
50857     } catch (std::exception& e) {
50858       {
50859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50860       };
50861     } catch (...) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50864       };
50865     }
50866   }
50867 }
50868
50869
50870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50871   void * jresult ;
50872   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50873
50874   {
50875     try {
50876       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50877     } catch (std::out_of_range& e) {
50878       {
50879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50880       };
50881     } catch (std::exception& e) {
50882       {
50883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50884       };
50885     } catch (...) {
50886       {
50887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50888       };
50889     }
50890   }
50891   jresult = (void *)result;
50892   return jresult;
50893 }
50894
50895
50896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50897   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50898
50899   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50900   {
50901     try {
50902       delete arg1;
50903     } catch (std::out_of_range& e) {
50904       {
50905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50906       };
50907     } catch (std::exception& e) {
50908       {
50909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50910       };
50911     } catch (...) {
50912       {
50913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50914       };
50915     }
50916   }
50917 }
50918
50919
50920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50921   unsigned int jresult ;
50922   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50923   bool result;
50924
50925   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50926   {
50927     try {
50928       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50929     } catch (std::out_of_range& e) {
50930       {
50931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50932       };
50933     } catch (std::exception& e) {
50934       {
50935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50936       };
50937     } catch (...) {
50938       {
50939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50940       };
50941     }
50942   }
50943   jresult = result;
50944   return jresult;
50945 }
50946
50947
50948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50949   unsigned long jresult ;
50950   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50951   std::size_t result;
50952
50953   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50954   {
50955     try {
50956       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (...) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50968       };
50969     }
50970   }
50971   jresult = (unsigned long)result;
50972   return jresult;
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50977   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50978   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50979
50980   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50981   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50982   {
50983     try {
50984       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50985     } catch (std::out_of_range& e) {
50986       {
50987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50988       };
50989     } catch (std::exception& e) {
50990       {
50991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50992       };
50993     } catch (...) {
50994       {
50995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50996       };
50997     }
50998   }
50999 }
51000
51001
51002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51003   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51004   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51005
51006   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51007   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51008   {
51009     try {
51010       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51011     } catch (std::out_of_range& e) {
51012       {
51013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51014       };
51015     } catch (std::exception& e) {
51016       {
51017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51018       };
51019     } catch (...) {
51020       {
51021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51022       };
51023     }
51024   }
51025 }
51026
51027
51028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51029   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51030   Dali::KeyEvent *arg2 = 0 ;
51031
51032   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51033   arg2 = (Dali::KeyEvent *)jarg2;
51034   if (!arg2) {
51035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51036     return ;
51037   }
51038   {
51039     try {
51040       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51041     } catch (std::out_of_range& e) {
51042       {
51043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51044       };
51045     } catch (std::exception& e) {
51046       {
51047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51048       };
51049     } catch (...) {
51050       {
51051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51052       };
51053     }
51054   }
51055 }
51056
51057
51058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51059   void * jresult ;
51060   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51061
51062   {
51063     try {
51064       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51076       };
51077     }
51078   }
51079   jresult = (void *)result;
51080   return jresult;
51081 }
51082
51083
51084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51085   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51086
51087   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51088   {
51089     try {
51090       delete arg1;
51091     } catch (std::out_of_range& e) {
51092       {
51093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51094       };
51095     } catch (std::exception& e) {
51096       {
51097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (...) {
51100       {
51101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51102       };
51103     }
51104   }
51105 }
51106
51107
51108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51109   unsigned int jresult ;
51110   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51111   bool result;
51112
51113   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51114   {
51115     try {
51116       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51117     } catch (std::out_of_range& e) {
51118       {
51119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51120       };
51121     } catch (std::exception& e) {
51122       {
51123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51124       };
51125     } catch (...) {
51126       {
51127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51128       };
51129     }
51130   }
51131   jresult = result;
51132   return jresult;
51133 }
51134
51135
51136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51137   unsigned long jresult ;
51138   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51139   std::size_t result;
51140
51141   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51142   {
51143     try {
51144       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51145     } catch (std::out_of_range& e) {
51146       {
51147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (std::exception& e) {
51150       {
51151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51156       };
51157     }
51158   }
51159   jresult = (unsigned long)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51165   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51166   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51167
51168   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51169   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51170   {
51171     try {
51172       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51173     } catch (std::out_of_range& e) {
51174       {
51175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51176       };
51177     } catch (std::exception& e) {
51178       {
51179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51180       };
51181     } catch (...) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51184       };
51185     }
51186   }
51187 }
51188
51189
51190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51191   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51192   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51193
51194   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51195   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51196   {
51197     try {
51198       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51199     } catch (std::out_of_range& e) {
51200       {
51201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51202       };
51203     } catch (std::exception& e) {
51204       {
51205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51206       };
51207     } catch (...) {
51208       {
51209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51210       };
51211     }
51212   }
51213 }
51214
51215
51216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51217   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51218   Dali::TouchData *arg2 = 0 ;
51219
51220   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51221   arg2 = (Dali::TouchData *)jarg2;
51222   if (!arg2) {
51223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51224     return ;
51225   }
51226   {
51227     try {
51228       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51229     } catch (std::out_of_range& e) {
51230       {
51231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51232       };
51233     } catch (std::exception& e) {
51234       {
51235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51236       };
51237     } catch (...) {
51238       {
51239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51240       };
51241     }
51242   }
51243 }
51244
51245
51246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51247   void * jresult ;
51248   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51249
51250   {
51251     try {
51252       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51253     } catch (std::out_of_range& e) {
51254       {
51255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51256       };
51257     } catch (std::exception& e) {
51258       {
51259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51260       };
51261     } catch (...) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51264       };
51265     }
51266   }
51267   jresult = (void *)result;
51268   return jresult;
51269 }
51270
51271
51272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51273   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51274
51275   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51276   {
51277     try {
51278       delete arg1;
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293 }
51294
51295
51296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51297   unsigned int jresult ;
51298   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51299   bool result;
51300
51301   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51302   {
51303     try {
51304       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51305     } catch (std::out_of_range& e) {
51306       {
51307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51308       };
51309     } catch (std::exception& e) {
51310       {
51311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51312       };
51313     } catch (...) {
51314       {
51315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51316       };
51317     }
51318   }
51319   jresult = result;
51320   return jresult;
51321 }
51322
51323
51324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51325   unsigned long jresult ;
51326   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51327   std::size_t result;
51328
51329   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51330   {
51331     try {
51332       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (...) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51344       };
51345     }
51346   }
51347   jresult = (unsigned long)result;
51348   return jresult;
51349 }
51350
51351
51352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51353   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51354   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51355
51356   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51357   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51358   {
51359     try {
51360       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51361     } catch (std::out_of_range& e) {
51362       {
51363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51364       };
51365     } catch (std::exception& e) {
51366       {
51367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51368       };
51369     } catch (...) {
51370       {
51371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51372       };
51373     }
51374   }
51375 }
51376
51377
51378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51379   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51380   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51381
51382   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51383   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51384   {
51385     try {
51386       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51387     } catch (std::out_of_range& e) {
51388       {
51389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51390       };
51391     } catch (std::exception& e) {
51392       {
51393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51394       };
51395     } catch (...) {
51396       {
51397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51398       };
51399     }
51400   }
51401 }
51402
51403
51404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51405   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51406   Dali::WheelEvent *arg2 = 0 ;
51407
51408   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51409   arg2 = (Dali::WheelEvent *)jarg2;
51410   if (!arg2) {
51411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51412     return ;
51413   }
51414   {
51415     try {
51416       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51417     } catch (std::out_of_range& e) {
51418       {
51419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51420       };
51421     } catch (std::exception& e) {
51422       {
51423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51424       };
51425     } catch (...) {
51426       {
51427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51428       };
51429     }
51430   }
51431 }
51432
51433
51434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51435   void * jresult ;
51436   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51437
51438   {
51439     try {
51440       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51452       };
51453     }
51454   }
51455   jresult = (void *)result;
51456   return jresult;
51457 }
51458
51459
51460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51461   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51462
51463   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51464   {
51465     try {
51466       delete arg1;
51467     } catch (std::out_of_range& e) {
51468       {
51469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (std::exception& e) {
51472       {
51473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481 }
51482
51483
51484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51485   void * jresult ;
51486   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51487
51488   {
51489     try {
51490       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51491     } catch (std::out_of_range& e) {
51492       {
51493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51494       };
51495     } catch (std::exception& e) {
51496       {
51497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51498       };
51499     } catch (...) {
51500       {
51501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51502       };
51503     }
51504   }
51505   jresult = (void *)result;
51506   return jresult;
51507 }
51508
51509
51510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51511   void * jresult ;
51512   Dali::Radian arg1 ;
51513   Dali::Radian arg2 ;
51514   Dali::Radian *argp1 ;
51515   Dali::Radian *argp2 ;
51516   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51517
51518   argp1 = (Dali::Radian *)jarg1;
51519   if (!argp1) {
51520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51521     return 0;
51522   }
51523   arg1 = *argp1;
51524   argp2 = (Dali::Radian *)jarg2;
51525   if (!argp2) {
51526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51527     return 0;
51528   }
51529   arg2 = *argp2;
51530   {
51531     try {
51532       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51533     } catch (std::out_of_range& e) {
51534       {
51535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51536       };
51537     } catch (std::exception& e) {
51538       {
51539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51540       };
51541     } catch (...) {
51542       {
51543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51544       };
51545     }
51546   }
51547   jresult = (void *)result;
51548   return jresult;
51549 }
51550
51551
51552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51553   void * jresult ;
51554   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51555   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51556
51557   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51558   if (!arg1) {
51559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51560     return 0;
51561   }
51562   {
51563     try {
51564       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51565     } catch (std::out_of_range& e) {
51566       {
51567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51568       };
51569     } catch (std::exception& e) {
51570       {
51571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51572       };
51573     } catch (...) {
51574       {
51575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51576       };
51577     }
51578   }
51579   jresult = (void *)result;
51580   return jresult;
51581 }
51582
51583
51584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51585   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51586   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51587
51588   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51589   arg2 = (Dali::Radian *)jarg2;
51590   if (arg1) (arg1)->first = *arg2;
51591 }
51592
51593
51594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51595   void * jresult ;
51596   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51597   Dali::Radian *result = 0 ;
51598
51599   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51600   result = (Dali::Radian *)& ((arg1)->first);
51601   jresult = (void *)result;
51602   return jresult;
51603 }
51604
51605
51606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51607   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51608   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51609
51610   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51611   arg2 = (Dali::Radian *)jarg2;
51612   if (arg1) (arg1)->second = *arg2;
51613 }
51614
51615
51616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51617   void * jresult ;
51618   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51619   Dali::Radian *result = 0 ;
51620
51621   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51622   result = (Dali::Radian *)& ((arg1)->second);
51623   jresult = (void *)result;
51624   return jresult;
51625 }
51626
51627
51628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51629   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51630
51631   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51632   {
51633     try {
51634       delete arg1;
51635     } catch (std::out_of_range& e) {
51636       {
51637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (std::exception& e) {
51640       {
51641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (...) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51646       };
51647     }
51648   }
51649 }
51650
51651
51652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51653   unsigned int jresult ;
51654   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51655   bool result;
51656
51657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51658   {
51659     try {
51660       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);
51661     } catch (std::out_of_range& e) {
51662       {
51663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51664       };
51665     } catch (std::exception& e) {
51666       {
51667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51668       };
51669     } catch (...) {
51670       {
51671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51672       };
51673     }
51674   }
51675   jresult = result;
51676   return jresult;
51677 }
51678
51679
51680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51681   unsigned long jresult ;
51682   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51683   std::size_t result;
51684
51685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51686   {
51687     try {
51688       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);
51689     } catch (std::out_of_range& e) {
51690       {
51691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51692       };
51693     } catch (std::exception& e) {
51694       {
51695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51696       };
51697     } catch (...) {
51698       {
51699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51700       };
51701     }
51702   }
51703   jresult = (unsigned long)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51709   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51710   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51711
51712   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51713   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51714   {
51715     try {
51716       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51717     } catch (std::out_of_range& e) {
51718       {
51719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (std::exception& e) {
51722       {
51723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51724       };
51725     } catch (...) {
51726       {
51727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51728       };
51729     }
51730   }
51731 }
51732
51733
51734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51735   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51736   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51737
51738   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51739   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51740   {
51741     try {
51742       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51743     } catch (std::out_of_range& e) {
51744       {
51745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51746       };
51747     } catch (std::exception& e) {
51748       {
51749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51750       };
51751     } catch (...) {
51752       {
51753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51754       };
51755     }
51756   }
51757 }
51758
51759
51760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51761   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51762   Dali::Actor arg2 ;
51763   Dali::PanGesture *arg3 = 0 ;
51764   Dali::Actor *argp2 ;
51765
51766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51767   argp2 = (Dali::Actor *)jarg2;
51768   if (!argp2) {
51769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51770     return ;
51771   }
51772   arg2 = *argp2;
51773   arg3 = (Dali::PanGesture *)jarg3;
51774   if (!arg3) {
51775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51776     return ;
51777   }
51778   {
51779     try {
51780       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51781     } catch (std::out_of_range& e) {
51782       {
51783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51784       };
51785     } catch (std::exception& e) {
51786       {
51787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51792       };
51793     }
51794   }
51795 }
51796
51797
51798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51799   void * jresult ;
51800   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51801
51802   {
51803     try {
51804       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51805     } catch (std::out_of_range& e) {
51806       {
51807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51808       };
51809     } catch (std::exception& e) {
51810       {
51811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51812       };
51813     } catch (...) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51816       };
51817     }
51818   }
51819   jresult = (void *)result;
51820   return jresult;
51821 }
51822
51823
51824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51825   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51826
51827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51828   {
51829     try {
51830       delete arg1;
51831     } catch (std::out_of_range& e) {
51832       {
51833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51834       };
51835     } catch (std::exception& e) {
51836       {
51837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51838       };
51839     } catch (...) {
51840       {
51841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51842       };
51843     }
51844   }
51845 }
51846
51847
51848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51849   unsigned int jresult ;
51850   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51851   bool result;
51852
51853   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51854   {
51855     try {
51856       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);
51857     } catch (std::out_of_range& e) {
51858       {
51859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (std::exception& e) {
51862       {
51863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51864       };
51865     } catch (...) {
51866       {
51867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51868       };
51869     }
51870   }
51871   jresult = result;
51872   return jresult;
51873 }
51874
51875
51876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51877   unsigned long jresult ;
51878   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51879   std::size_t result;
51880
51881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51882   {
51883     try {
51884       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);
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (unsigned long)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51905   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51906   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51907
51908   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51909   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51910   {
51911     try {
51912       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51913     } catch (std::out_of_range& e) {
51914       {
51915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51916       };
51917     } catch (std::exception& e) {
51918       {
51919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51920       };
51921     } catch (...) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51924       };
51925     }
51926   }
51927 }
51928
51929
51930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51931   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51932   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51933
51934   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51935   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51936   {
51937     try {
51938       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51939     } catch (std::out_of_range& e) {
51940       {
51941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51942       };
51943     } catch (std::exception& e) {
51944       {
51945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51950       };
51951     }
51952   }
51953 }
51954
51955
51956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51957   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51958   Dali::Actor arg2 ;
51959   Dali::PinchGesture *arg3 = 0 ;
51960   Dali::Actor *argp2 ;
51961
51962   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51963   argp2 = (Dali::Actor *)jarg2;
51964   if (!argp2) {
51965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51966     return ;
51967   }
51968   arg2 = *argp2;
51969   arg3 = (Dali::PinchGesture *)jarg3;
51970   if (!arg3) {
51971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51972     return ;
51973   }
51974   {
51975     try {
51976       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51977     } catch (std::out_of_range& e) {
51978       {
51979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51980       };
51981     } catch (std::exception& e) {
51982       {
51983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51984       };
51985     } catch (...) {
51986       {
51987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51988       };
51989     }
51990   }
51991 }
51992
51993
51994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51995   void * jresult ;
51996   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51997
51998   {
51999     try {
52000       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52001     } catch (std::out_of_range& e) {
52002       {
52003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52004       };
52005     } catch (std::exception& e) {
52006       {
52007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52008       };
52009     } catch (...) {
52010       {
52011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52012       };
52013     }
52014   }
52015   jresult = (void *)result;
52016   return jresult;
52017 }
52018
52019
52020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52021   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52022
52023   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52024   {
52025     try {
52026       delete arg1;
52027     } catch (std::out_of_range& e) {
52028       {
52029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (std::exception& e) {
52032       {
52033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52034       };
52035     } catch (...) {
52036       {
52037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52038       };
52039     }
52040   }
52041 }
52042
52043
52044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52045   unsigned int jresult ;
52046   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52047   bool result;
52048
52049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52050   {
52051     try {
52052       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);
52053     } catch (std::out_of_range& e) {
52054       {
52055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52056       };
52057     } catch (std::exception& e) {
52058       {
52059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52060       };
52061     } catch (...) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52064       };
52065     }
52066   }
52067   jresult = result;
52068   return jresult;
52069 }
52070
52071
52072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52073   unsigned long jresult ;
52074   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52075   std::size_t result;
52076
52077   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52078   {
52079     try {
52080       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);
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095   jresult = (unsigned long)result;
52096   return jresult;
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52101   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52102   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52103
52104   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52105   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52106   {
52107     try {
52108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52109     } catch (std::out_of_range& e) {
52110       {
52111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52112       };
52113     } catch (std::exception& e) {
52114       {
52115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52116       };
52117     } catch (...) {
52118       {
52119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52120       };
52121     }
52122   }
52123 }
52124
52125
52126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52127   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52128   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52129
52130   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52131   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52132   {
52133     try {
52134       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52135     } catch (std::out_of_range& e) {
52136       {
52137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52138       };
52139     } catch (std::exception& e) {
52140       {
52141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52142       };
52143     } catch (...) {
52144       {
52145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52146       };
52147     }
52148   }
52149 }
52150
52151
52152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52153   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52154   Dali::Actor arg2 ;
52155   Dali::TapGesture *arg3 = 0 ;
52156   Dali::Actor *argp2 ;
52157
52158   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52159   argp2 = (Dali::Actor *)jarg2;
52160   if (!argp2) {
52161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52162     return ;
52163   }
52164   arg2 = *argp2;
52165   arg3 = (Dali::TapGesture *)jarg3;
52166   if (!arg3) {
52167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52168     return ;
52169   }
52170   {
52171     try {
52172       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52173     } catch (std::out_of_range& e) {
52174       {
52175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52176       };
52177     } catch (std::exception& e) {
52178       {
52179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52180       };
52181     } catch (...) {
52182       {
52183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52184       };
52185     }
52186   }
52187 }
52188
52189
52190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52191   void * jresult ;
52192   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52193
52194   {
52195     try {
52196       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52197     } catch (std::out_of_range& e) {
52198       {
52199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (std::exception& e) {
52202       {
52203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52204       };
52205     } catch (...) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52208       };
52209     }
52210   }
52211   jresult = (void *)result;
52212   return jresult;
52213 }
52214
52215
52216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52217   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52218
52219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52220   {
52221     try {
52222       delete arg1;
52223     } catch (std::out_of_range& e) {
52224       {
52225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52226       };
52227     } catch (std::exception& e) {
52228       {
52229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52230       };
52231     } catch (...) {
52232       {
52233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52234       };
52235     }
52236   }
52237 }
52238
52239
52240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52241   unsigned int jresult ;
52242   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52243   bool result;
52244
52245   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52246   {
52247     try {
52248       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52249     } catch (std::out_of_range& e) {
52250       {
52251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52252       };
52253     } catch (std::exception& e) {
52254       {
52255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52256       };
52257     } catch (...) {
52258       {
52259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52260       };
52261     }
52262   }
52263   jresult = result;
52264   return jresult;
52265 }
52266
52267
52268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52269   unsigned long jresult ;
52270   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52271   std::size_t result;
52272
52273   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52274   {
52275     try {
52276       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52277     } catch (std::out_of_range& e) {
52278       {
52279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52280       };
52281     } catch (std::exception& e) {
52282       {
52283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52284       };
52285     } catch (...) {
52286       {
52287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52288       };
52289     }
52290   }
52291   jresult = (unsigned long)result;
52292   return jresult;
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52297   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52298   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52299
52300   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52301   arg2 = (void (*)(Dali::Animation &))jarg2;
52302   {
52303     try {
52304       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52305     } catch (std::out_of_range& e) {
52306       {
52307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52308       };
52309     } catch (std::exception& e) {
52310       {
52311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52312       };
52313     } catch (...) {
52314       {
52315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52316       };
52317     }
52318   }
52319 }
52320
52321
52322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52323   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52324   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52325
52326   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52327   arg2 = (void (*)(Dali::Animation &))jarg2;
52328   {
52329     try {
52330       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52331     } catch (std::out_of_range& e) {
52332       {
52333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52334       };
52335     } catch (std::exception& e) {
52336       {
52337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52338       };
52339     } catch (...) {
52340       {
52341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52342       };
52343     }
52344   }
52345 }
52346
52347
52348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52349   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52350   Dali::Animation *arg2 = 0 ;
52351
52352   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52353   arg2 = (Dali::Animation *)jarg2;
52354   if (!arg2) {
52355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52356     return ;
52357   }
52358   {
52359     try {
52360       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52361     } catch (std::out_of_range& e) {
52362       {
52363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52364       };
52365     } catch (std::exception& e) {
52366       {
52367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52368       };
52369     } catch (...) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52372       };
52373     }
52374   }
52375 }
52376
52377
52378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52379   void * jresult ;
52380   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52381
52382   {
52383     try {
52384       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52392       };
52393     } catch (...) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52396       };
52397     }
52398   }
52399   jresult = (void *)result;
52400   return jresult;
52401 }
52402
52403
52404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52405   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52406
52407   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52408   {
52409     try {
52410       delete arg1;
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52418       };
52419     } catch (...) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52422       };
52423     }
52424   }
52425 }
52426
52427
52428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52429   unsigned int jresult ;
52430   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52431   bool result;
52432
52433   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52434   {
52435     try {
52436       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52437     } catch (std::out_of_range& e) {
52438       {
52439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (std::exception& e) {
52442       {
52443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52444       };
52445     } catch (...) {
52446       {
52447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52448       };
52449     }
52450   }
52451   jresult = result;
52452   return jresult;
52453 }
52454
52455
52456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52457   unsigned long jresult ;
52458   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52459   std::size_t result;
52460
52461   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52462   {
52463     try {
52464       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52465     } catch (std::out_of_range& e) {
52466       {
52467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (std::exception& e) {
52470       {
52471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52472       };
52473     } catch (...) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52476       };
52477     }
52478   }
52479   jresult = (unsigned long)result;
52480   return jresult;
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52485   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52486   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52487
52488   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52489   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52490   {
52491     try {
52492       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52493     } catch (std::out_of_range& e) {
52494       {
52495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52496       };
52497     } catch (std::exception& e) {
52498       {
52499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52500       };
52501     } catch (...) {
52502       {
52503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52504       };
52505     }
52506   }
52507 }
52508
52509
52510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52511   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52512   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52513
52514   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52515   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52516   {
52517     try {
52518       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52519     } catch (std::out_of_range& e) {
52520       {
52521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52522       };
52523     } catch (std::exception& e) {
52524       {
52525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52526       };
52527     } catch (...) {
52528       {
52529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52530       };
52531     }
52532   }
52533 }
52534
52535
52536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52537   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52538   Dali::ResourceImage arg2 ;
52539   Dali::ResourceImage *argp2 ;
52540
52541   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52542   argp2 = (Dali::ResourceImage *)jarg2;
52543   if (!argp2) {
52544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52545     return ;
52546   }
52547   arg2 = *argp2;
52548   {
52549     try {
52550       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52551     } catch (std::out_of_range& e) {
52552       {
52553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52554       };
52555     } catch (std::exception& e) {
52556       {
52557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52558       };
52559     } catch (...) {
52560       {
52561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52562       };
52563     }
52564   }
52565 }
52566
52567
52568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52569   void * jresult ;
52570   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52571
52572   {
52573     try {
52574       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52575     } catch (std::out_of_range& e) {
52576       {
52577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52578       };
52579     } catch (std::exception& e) {
52580       {
52581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52582       };
52583     } catch (...) {
52584       {
52585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52586       };
52587     }
52588   }
52589   jresult = (void *)result;
52590   return jresult;
52591 }
52592
52593
52594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52595   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52596
52597   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52598   {
52599     try {
52600       delete arg1;
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (...) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52612       };
52613     }
52614   }
52615 }
52616
52617
52618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52619   unsigned int jresult ;
52620   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52621   bool result;
52622
52623   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52624   {
52625     try {
52626       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);
52627     } catch (std::out_of_range& e) {
52628       {
52629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (std::exception& e) {
52632       {
52633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52634       };
52635     } catch (...) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52638       };
52639     }
52640   }
52641   jresult = result;
52642   return jresult;
52643 }
52644
52645
52646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52647   unsigned long jresult ;
52648   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52649   std::size_t result;
52650
52651   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52652   {
52653     try {
52654       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);
52655     } catch (std::out_of_range& e) {
52656       {
52657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (std::exception& e) {
52660       {
52661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (...) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52666       };
52667     }
52668   }
52669   jresult = (unsigned long)result;
52670   return jresult;
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52675   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52676   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52677
52678   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52679   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52680   {
52681     try {
52682       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52683     } catch (std::out_of_range& e) {
52684       {
52685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52686       };
52687     } catch (std::exception& e) {
52688       {
52689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52690       };
52691     } catch (...) {
52692       {
52693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52694       };
52695     }
52696   }
52697 }
52698
52699
52700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52701   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52702   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52703
52704   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52705   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52706   {
52707     try {
52708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52709     } catch (std::out_of_range& e) {
52710       {
52711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (std::exception& e) {
52714       {
52715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52720       };
52721     }
52722   }
52723 }
52724
52725
52726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52727   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52728   Dali::Actor arg2 ;
52729   bool arg3 ;
52730   Dali::DevelActor::VisibilityChange::Type arg4 ;
52731   Dali::Actor *argp2 ;
52732
52733   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52734   argp2 = (Dali::Actor *)jarg2;
52735   if (!argp2) {
52736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52737     return ;
52738   }
52739   arg2 = *argp2;
52740   arg3 = jarg3 ? true : false;
52741   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52742   {
52743     try {
52744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52745     } catch (std::out_of_range& e) {
52746       {
52747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52748       };
52749     } catch (std::exception& e) {
52750       {
52751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52752       };
52753     } catch (...) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52756       };
52757     }
52758   }
52759 }
52760
52761
52762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52763   void * jresult ;
52764   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52765
52766   {
52767     try {
52768       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52769     } catch (std::out_of_range& e) {
52770       {
52771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52772       };
52773     } catch (std::exception& e) {
52774       {
52775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52776       };
52777     } catch (...) {
52778       {
52779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52780       };
52781     }
52782   }
52783   jresult = (void *)result;
52784   return jresult;
52785 }
52786
52787
52788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52789   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52790
52791   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52792   {
52793     try {
52794       delete arg1;
52795     } catch (std::out_of_range& e) {
52796       {
52797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52798       };
52799     } catch (std::exception& e) {
52800       {
52801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52802       };
52803     } catch (...) {
52804       {
52805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52806       };
52807     }
52808   }
52809 }
52810
52811
52812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52813   void * jresult ;
52814   Dali::Timer *result = 0 ;
52815
52816   {
52817     try {
52818       result = (Dali::Timer *)new Dali::Timer();
52819     } catch (std::out_of_range& e) {
52820       {
52821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52822       };
52823     } catch (std::exception& e) {
52824       {
52825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52826       };
52827     } catch (...) {
52828       {
52829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52830       };
52831     }
52832   }
52833   jresult = (void *)result;
52834   return jresult;
52835 }
52836
52837
52838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52839   void * jresult ;
52840   unsigned int arg1 ;
52841   Dali::Timer result;
52842
52843   arg1 = (unsigned int)jarg1;
52844   {
52845     try {
52846       result = Dali::Timer::New(arg1);
52847     } catch (std::out_of_range& e) {
52848       {
52849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52850       };
52851     } catch (std::exception& e) {
52852       {
52853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52854       };
52855     } catch (...) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52858       };
52859     }
52860   }
52861   jresult = new Dali::Timer((const Dali::Timer &)result);
52862   return jresult;
52863 }
52864
52865
52866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52867   void * jresult ;
52868   Dali::Timer *arg1 = 0 ;
52869   Dali::Timer *result = 0 ;
52870
52871   arg1 = (Dali::Timer *)jarg1;
52872   if (!arg1) {
52873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52874     return 0;
52875   }
52876   {
52877     try {
52878       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52879     } catch (std::out_of_range& e) {
52880       {
52881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52882       };
52883     } catch (std::exception& e) {
52884       {
52885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52886       };
52887     } catch (...) {
52888       {
52889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52890       };
52891     }
52892   }
52893   jresult = (void *)result;
52894   return jresult;
52895 }
52896
52897
52898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52899   void * jresult ;
52900   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52901   Dali::Timer *arg2 = 0 ;
52902   Dali::Timer *result = 0 ;
52903
52904   arg1 = (Dali::Timer *)jarg1;
52905   arg2 = (Dali::Timer *)jarg2;
52906   if (!arg2) {
52907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52908     return 0;
52909   }
52910   {
52911     try {
52912       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52913     } catch (std::out_of_range& e) {
52914       {
52915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52916       };
52917     } catch (std::exception& e) {
52918       {
52919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52920       };
52921     } catch (...) {
52922       {
52923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52924       };
52925     }
52926   }
52927   jresult = (void *)result;
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52933   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52934
52935   arg1 = (Dali::Timer *)jarg1;
52936   {
52937     try {
52938       delete arg1;
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52950       };
52951     }
52952   }
52953 }
52954
52955
52956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52957   void * jresult ;
52958   Dali::BaseHandle arg1 ;
52959   Dali::BaseHandle *argp1 ;
52960   Dali::Timer result;
52961
52962   argp1 = (Dali::BaseHandle *)jarg1;
52963   if (!argp1) {
52964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52965     return 0;
52966   }
52967   arg1 = *argp1;
52968   {
52969     try {
52970       result = Dali::Timer::DownCast(arg1);
52971     } catch (std::out_of_range& e) {
52972       {
52973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (std::exception& e) {
52976       {
52977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52982       };
52983     }
52984   }
52985   jresult = new Dali::Timer((const Dali::Timer &)result);
52986   return jresult;
52987 }
52988
52989
52990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52991   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52992
52993   arg1 = (Dali::Timer *)jarg1;
52994   {
52995     try {
52996       (arg1)->Start();
52997     } catch (std::out_of_range& e) {
52998       {
52999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53000       };
53001     } catch (std::exception& e) {
53002       {
53003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53004       };
53005     } catch (...) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53008       };
53009     }
53010   }
53011 }
53012
53013
53014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53015   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53016
53017   arg1 = (Dali::Timer *)jarg1;
53018   {
53019     try {
53020       (arg1)->Stop();
53021     } catch (std::out_of_range& e) {
53022       {
53023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53024       };
53025     } catch (std::exception& e) {
53026       {
53027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53028       };
53029     } catch (...) {
53030       {
53031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53032       };
53033     }
53034   }
53035 }
53036
53037
53038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53039   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53040   unsigned int arg2 ;
53041
53042   arg1 = (Dali::Timer *)jarg1;
53043   arg2 = (unsigned int)jarg2;
53044   {
53045     try {
53046       (arg1)->SetInterval(arg2);
53047     } catch (std::out_of_range& e) {
53048       {
53049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (std::exception& e) {
53052       {
53053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53054       };
53055     } catch (...) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53058       };
53059     }
53060   }
53061 }
53062
53063
53064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53065   unsigned int jresult ;
53066   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53067   unsigned int result;
53068
53069   arg1 = (Dali::Timer *)jarg1;
53070   {
53071     try {
53072       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53073     } catch (std::out_of_range& e) {
53074       {
53075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53076       };
53077     } catch (std::exception& e) {
53078       {
53079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53080       };
53081     } catch (...) {
53082       {
53083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53084       };
53085     }
53086   }
53087   jresult = result;
53088   return jresult;
53089 }
53090
53091
53092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53093   unsigned int jresult ;
53094   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53095   bool result;
53096
53097   arg1 = (Dali::Timer *)jarg1;
53098   {
53099     try {
53100       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53108       };
53109     } catch (...) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53112       };
53113     }
53114   }
53115   jresult = result;
53116   return jresult;
53117 }
53118
53119
53120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53121   void * jresult ;
53122   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53123   Dali::Timer::TimerSignalType *result = 0 ;
53124
53125   arg1 = (Dali::Timer *)jarg1;
53126   {
53127     try {
53128       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53129     } catch (std::out_of_range& e) {
53130       {
53131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53132       };
53133     } catch (std::exception& e) {
53134       {
53135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53136       };
53137     } catch (...) {
53138       {
53139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53140       };
53141     }
53142   }
53143   jresult = (void *)result;
53144   return jresult;
53145 }
53146
53147
53148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53149   void * jresult ;
53150   Dali::DragAndDropDetector *result = 0 ;
53151
53152   {
53153     try {
53154       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53155     } catch (std::out_of_range& e) {
53156       {
53157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (std::exception& e) {
53160       {
53161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (...) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53166       };
53167     }
53168   }
53169   jresult = (void *)result;
53170   return jresult;
53171 }
53172
53173
53174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53175   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53176
53177   arg1 = (Dali::DragAndDropDetector *)jarg1;
53178   {
53179     try {
53180       delete arg1;
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53192       };
53193     }
53194   }
53195 }
53196
53197
53198 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53199   char * jresult ;
53200   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53201   std::string *result = 0 ;
53202
53203   arg1 = (Dali::DragAndDropDetector *)jarg1;
53204   {
53205     try {
53206       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53207     } catch (std::out_of_range& e) {
53208       {
53209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53210       };
53211     } catch (std::exception& e) {
53212       {
53213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53214       };
53215     } catch (...) {
53216       {
53217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53218       };
53219     }
53220   }
53221   jresult = SWIG_csharp_string_callback(result->c_str());
53222   return jresult;
53223 }
53224
53225
53226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53227   void * jresult ;
53228   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53229   Dali::Vector2 result;
53230
53231   arg1 = (Dali::DragAndDropDetector *)jarg1;
53232   {
53233     try {
53234       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53246       };
53247     }
53248   }
53249   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53250   return jresult;
53251 }
53252
53253
53254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53255   void * jresult ;
53256   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53257   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53258
53259   arg1 = (Dali::DragAndDropDetector *)jarg1;
53260   {
53261     try {
53262       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53263     } catch (std::out_of_range& e) {
53264       {
53265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53266       };
53267     } catch (std::exception& e) {
53268       {
53269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53270       };
53271     } catch (...) {
53272       {
53273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53274       };
53275     }
53276   }
53277   jresult = (void *)result;
53278   return jresult;
53279 }
53280
53281
53282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53283   void * jresult ;
53284   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53285   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53286
53287   arg1 = (Dali::DragAndDropDetector *)jarg1;
53288   {
53289     try {
53290       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53291     } catch (std::out_of_range& e) {
53292       {
53293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (std::exception& e) {
53296       {
53297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53298       };
53299     } catch (...) {
53300       {
53301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53302       };
53303     }
53304   }
53305   jresult = (void *)result;
53306   return jresult;
53307 }
53308
53309
53310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53311   void * jresult ;
53312   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53313   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53314
53315   arg1 = (Dali::DragAndDropDetector *)jarg1;
53316   {
53317     try {
53318       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53319     } catch (std::out_of_range& e) {
53320       {
53321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53322       };
53323     } catch (std::exception& e) {
53324       {
53325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53326       };
53327     } catch (...) {
53328       {
53329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53330       };
53331     }
53332   }
53333   jresult = (void *)result;
53334   return jresult;
53335 }
53336
53337
53338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53339   void * jresult ;
53340   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53341   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53342
53343   arg1 = (Dali::DragAndDropDetector *)jarg1;
53344   {
53345     try {
53346       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53347     } catch (std::out_of_range& e) {
53348       {
53349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (std::exception& e) {
53352       {
53353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53354       };
53355     } catch (...) {
53356       {
53357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53358       };
53359     }
53360   }
53361   jresult = (void *)result;
53362   return jresult;
53363 }
53364
53365
53366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53367   void * jresult ;
53368   Dali::ApplicationExtensions *result = 0 ;
53369
53370   {
53371     try {
53372       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53373     } catch (std::out_of_range& e) {
53374       {
53375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53376       };
53377     } catch (std::exception& e) {
53378       {
53379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53380       };
53381     } catch (...) {
53382       {
53383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53384       };
53385     }
53386   }
53387   jresult = (void *)result;
53388   return jresult;
53389 }
53390
53391
53392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53393   void * jresult ;
53394   Dali::Application *arg1 = (Dali::Application *) 0 ;
53395   Dali::ApplicationExtensions *result = 0 ;
53396
53397   arg1 = (Dali::Application *)jarg1;
53398   {
53399     try {
53400       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53401     } catch (std::out_of_range& e) {
53402       {
53403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53404       };
53405     } catch (std::exception& e) {
53406       {
53407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53408       };
53409     } catch (...) {
53410       {
53411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53412       };
53413     }
53414   }
53415   jresult = (void *)result;
53416   return jresult;
53417 }
53418
53419
53420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53421   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53422
53423   arg1 = (Dali::ApplicationExtensions *)jarg1;
53424   {
53425     try {
53426       delete arg1;
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53438       };
53439     }
53440   }
53441 }
53442
53443
53444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53445   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53446
53447   arg1 = (Dali::ApplicationExtensions *)jarg1;
53448   {
53449     try {
53450       (arg1)->Init();
53451     } catch (std::out_of_range& e) {
53452       {
53453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (std::exception& e) {
53456       {
53457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53462       };
53463     }
53464   }
53465 }
53466
53467
53468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53469   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53470
53471   arg1 = (Dali::ApplicationExtensions *)jarg1;
53472   {
53473     try {
53474       (arg1)->Terminate();
53475     } catch (std::out_of_range& e) {
53476       {
53477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53478       };
53479     } catch (std::exception& e) {
53480       {
53481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53482       };
53483     } catch (...) {
53484       {
53485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53486       };
53487     }
53488   }
53489 }
53490
53491
53492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53493   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53494
53495   arg1 = (Dali::ApplicationExtensions *)jarg1;
53496   {
53497     try {
53498       (arg1)->Pause();
53499     } catch (std::out_of_range& e) {
53500       {
53501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53502       };
53503     } catch (std::exception& e) {
53504       {
53505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53506       };
53507     } catch (...) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53510       };
53511     }
53512   }
53513 }
53514
53515
53516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53517   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53518
53519   arg1 = (Dali::ApplicationExtensions *)jarg1;
53520   {
53521     try {
53522       (arg1)->Resume();
53523     } catch (std::out_of_range& e) {
53524       {
53525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53526       };
53527     } catch (std::exception& e) {
53528       {
53529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53530       };
53531     } catch (...) {
53532       {
53533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53534       };
53535     }
53536   }
53537 }
53538
53539
53540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53541   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53542
53543   arg1 = (Dali::ApplicationExtensions *)jarg1;
53544   {
53545     try {
53546       (arg1)->LanguageChange();
53547     } catch (std::out_of_range& e) {
53548       {
53549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53550       };
53551     } catch (std::exception& e) {
53552       {
53553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53554       };
53555     } catch (...) {
53556       {
53557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53558       };
53559     }
53560   }
53561 }
53562
53563
53564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53565   void * jresult ;
53566   Dali::PositionSize arg1 ;
53567   std::string *arg2 = 0 ;
53568   bool arg3 ;
53569   Dali::PositionSize *argp1 ;
53570   Dali::Window result;
53571
53572   argp1 = (Dali::PositionSize *)jarg1;
53573   if (!argp1) {
53574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53575     return 0;
53576   }
53577   arg1 = *argp1;
53578   if (!jarg2) {
53579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53580     return 0;
53581   }
53582   std::string arg2_str(jarg2);
53583   arg2 = &arg2_str;
53584   arg3 = jarg3 ? true : false;
53585   {
53586     try {
53587       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (...) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53599       };
53600     }
53601   }
53602   jresult = new Dali::Window((const Dali::Window &)result);
53603
53604   //argout typemap for const std::string&
53605
53606   return jresult;
53607 }
53608
53609
53610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53611   void * jresult ;
53612   Dali::PositionSize arg1 ;
53613   std::string *arg2 = 0 ;
53614   Dali::PositionSize *argp1 ;
53615   Dali::Window result;
53616
53617   argp1 = (Dali::PositionSize *)jarg1;
53618   if (!argp1) {
53619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53620     return 0;
53621   }
53622   arg1 = *argp1;
53623   if (!jarg2) {
53624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53625     return 0;
53626   }
53627   std::string arg2_str(jarg2);
53628   arg2 = &arg2_str;
53629   {
53630     try {
53631       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53632     } catch (std::out_of_range& e) {
53633       {
53634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53635       };
53636     } catch (std::exception& e) {
53637       {
53638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53639       };
53640     } catch (...) {
53641       {
53642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53643       };
53644     }
53645   }
53646   jresult = new Dali::Window((const Dali::Window &)result);
53647
53648   //argout typemap for const std::string&
53649
53650   return jresult;
53651 }
53652
53653
53654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53655   void * jresult ;
53656   Dali::PositionSize arg1 ;
53657   std::string *arg2 = 0 ;
53658   std::string *arg3 = 0 ;
53659   bool arg4 ;
53660   Dali::PositionSize *argp1 ;
53661   Dali::Window result;
53662
53663   argp1 = (Dali::PositionSize *)jarg1;
53664   if (!argp1) {
53665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53666     return 0;
53667   }
53668   arg1 = *argp1;
53669   if (!jarg2) {
53670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53671     return 0;
53672   }
53673   std::string arg2_str(jarg2);
53674   arg2 = &arg2_str;
53675   if (!jarg3) {
53676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53677     return 0;
53678   }
53679   std::string arg3_str(jarg3);
53680   arg3 = &arg3_str;
53681   arg4 = jarg4 ? true : false;
53682   {
53683     try {
53684       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53685     } catch (std::out_of_range& e) {
53686       {
53687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53688       };
53689     } catch (std::exception& e) {
53690       {
53691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53692       };
53693     } catch (...) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53696       };
53697     }
53698   }
53699   jresult = new Dali::Window((const Dali::Window &)result);
53700
53701   //argout typemap for const std::string&
53702
53703
53704   //argout typemap for const std::string&
53705
53706   return jresult;
53707 }
53708
53709
53710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53711   void * jresult ;
53712   Dali::PositionSize arg1 ;
53713   std::string *arg2 = 0 ;
53714   std::string *arg3 = 0 ;
53715   Dali::PositionSize *argp1 ;
53716   Dali::Window result;
53717
53718   argp1 = (Dali::PositionSize *)jarg1;
53719   if (!argp1) {
53720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53721     return 0;
53722   }
53723   arg1 = *argp1;
53724   if (!jarg2) {
53725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53726     return 0;
53727   }
53728   std::string arg2_str(jarg2);
53729   arg2 = &arg2_str;
53730   if (!jarg3) {
53731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53732     return 0;
53733   }
53734   std::string arg3_str(jarg3);
53735   arg3 = &arg3_str;
53736   {
53737     try {
53738       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53739     } catch (std::out_of_range& e) {
53740       {
53741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53742       };
53743     } catch (std::exception& e) {
53744       {
53745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53746       };
53747     } catch (...) {
53748       {
53749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53750       };
53751     }
53752   }
53753   jresult = new Dali::Window((const Dali::Window &)result);
53754
53755   //argout typemap for const std::string&
53756
53757
53758   //argout typemap for const std::string&
53759
53760   return jresult;
53761 }
53762
53763
53764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53765   void * jresult ;
53766   Dali::Window *result = 0 ;
53767
53768   {
53769     try {
53770       result = (Dali::Window *)new Dali::Window();
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (...) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53782       };
53783     }
53784   }
53785   jresult = (void *)result;
53786   return jresult;
53787 }
53788
53789
53790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53791   Dali::Window *arg1 = (Dali::Window *) 0 ;
53792
53793   arg1 = (Dali::Window *)jarg1;
53794   {
53795     try {
53796       delete arg1;
53797     } catch (std::out_of_range& e) {
53798       {
53799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53800       };
53801     } catch (std::exception& e) {
53802       {
53803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53804       };
53805     } catch (...) {
53806       {
53807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53808       };
53809     }
53810   }
53811 }
53812
53813
53814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53815   void * jresult ;
53816   Dali::Window *arg1 = 0 ;
53817   Dali::Window *result = 0 ;
53818
53819   arg1 = (Dali::Window *)jarg1;
53820   if (!arg1) {
53821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53822     return 0;
53823   }
53824   {
53825     try {
53826       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53827     } catch (std::out_of_range& e) {
53828       {
53829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53830       };
53831     } catch (std::exception& e) {
53832       {
53833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53834       };
53835     } catch (...) {
53836       {
53837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53838       };
53839     }
53840   }
53841   jresult = (void *)result;
53842   return jresult;
53843 }
53844
53845
53846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53847   void * jresult ;
53848   Dali::Window *arg1 = (Dali::Window *) 0 ;
53849   Dali::Window *arg2 = 0 ;
53850   Dali::Window *result = 0 ;
53851
53852   arg1 = (Dali::Window *)jarg1;
53853   arg2 = (Dali::Window *)jarg2;
53854   if (!arg2) {
53855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53856     return 0;
53857   }
53858   {
53859     try {
53860       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53861     } catch (std::out_of_range& e) {
53862       {
53863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53864       };
53865     } catch (std::exception& e) {
53866       {
53867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53868       };
53869     } catch (...) {
53870       {
53871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53872       };
53873     }
53874   }
53875   jresult = (void *)result;
53876   return jresult;
53877 }
53878
53879
53880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53881   Dali::Window *arg1 = (Dali::Window *) 0 ;
53882   Dali::Window::IndicatorVisibleMode arg2 ;
53883
53884   arg1 = (Dali::Window *)jarg1;
53885   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53886   {
53887     try {
53888       (arg1)->ShowIndicator(arg2);
53889     } catch (std::out_of_range& e) {
53890       {
53891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53892       };
53893     } catch (std::exception& e) {
53894       {
53895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53896       };
53897     } catch (...) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53900       };
53901     }
53902   }
53903 }
53904
53905
53906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53907   Dali::Window *arg1 = (Dali::Window *) 0 ;
53908   Dali::Window::IndicatorBgOpacity arg2 ;
53909
53910   arg1 = (Dali::Window *)jarg1;
53911   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53912   {
53913     try {
53914       (arg1)->SetIndicatorBgOpacity(arg2);
53915     } catch (std::out_of_range& e) {
53916       {
53917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53918       };
53919     } catch (std::exception& e) {
53920       {
53921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53922       };
53923     } catch (...) {
53924       {
53925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53926       };
53927     }
53928   }
53929 }
53930
53931
53932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53933   Dali::Window *arg1 = (Dali::Window *) 0 ;
53934   Dali::Window::WindowOrientation arg2 ;
53935
53936   arg1 = (Dali::Window *)jarg1;
53937   arg2 = (Dali::Window::WindowOrientation)jarg2;
53938   {
53939     try {
53940       (arg1)->RotateIndicator(arg2);
53941     } catch (std::out_of_range& e) {
53942       {
53943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53944       };
53945     } catch (std::exception& e) {
53946       {
53947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53952       };
53953     }
53954   }
53955 }
53956
53957
53958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53959   Dali::Window *arg1 = (Dali::Window *) 0 ;
53960   std::string arg2 ;
53961   std::string arg3 ;
53962
53963   arg1 = (Dali::Window *)jarg1;
53964   if (!jarg2) {
53965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53966     return ;
53967   }
53968   (&arg2)->assign(jarg2);
53969   if (!jarg3) {
53970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53971     return ;
53972   }
53973   (&arg3)->assign(jarg3);
53974   {
53975     try {
53976       (arg1)->SetClass(arg2,arg3);
53977     } catch (std::out_of_range& e) {
53978       {
53979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53980       };
53981     } catch (std::exception& e) {
53982       {
53983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53984       };
53985     } catch (...) {
53986       {
53987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53988       };
53989     }
53990   }
53991 }
53992
53993
53994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53995   Dali::Window *arg1 = (Dali::Window *) 0 ;
53996
53997   arg1 = (Dali::Window *)jarg1;
53998   {
53999     try {
54000       (arg1)->Raise();
54001     } catch (std::out_of_range& e) {
54002       {
54003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (std::exception& e) {
54006       {
54007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54012       };
54013     }
54014   }
54015 }
54016
54017
54018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54019   Dali::Window *arg1 = (Dali::Window *) 0 ;
54020
54021   arg1 = (Dali::Window *)jarg1;
54022   {
54023     try {
54024       (arg1)->Lower();
54025     } catch (std::out_of_range& e) {
54026       {
54027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (std::exception& e) {
54030       {
54031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54032       };
54033     } catch (...) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54036       };
54037     }
54038   }
54039 }
54040
54041
54042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54043   Dali::Window *arg1 = (Dali::Window *) 0 ;
54044
54045   arg1 = (Dali::Window *)jarg1;
54046   {
54047     try {
54048       (arg1)->Activate();
54049     } catch (std::out_of_range& e) {
54050       {
54051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54052       };
54053     } catch (std::exception& e) {
54054       {
54055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54056       };
54057     } catch (...) {
54058       {
54059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54060       };
54061     }
54062   }
54063 }
54064
54065
54066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54067   Dali::Window *arg1 = (Dali::Window *) 0 ;
54068   Dali::Window::WindowOrientation arg2 ;
54069
54070   arg1 = (Dali::Window *)jarg1;
54071   arg2 = (Dali::Window::WindowOrientation)jarg2;
54072   {
54073     try {
54074       (arg1)->AddAvailableOrientation(arg2);
54075     } catch (std::out_of_range& e) {
54076       {
54077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54078       };
54079     } catch (std::exception& e) {
54080       {
54081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54082       };
54083     } catch (...) {
54084       {
54085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54086       };
54087     }
54088   }
54089 }
54090
54091
54092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54093   Dali::Window *arg1 = (Dali::Window *) 0 ;
54094   Dali::Window::WindowOrientation arg2 ;
54095
54096   arg1 = (Dali::Window *)jarg1;
54097   arg2 = (Dali::Window::WindowOrientation)jarg2;
54098   {
54099     try {
54100       (arg1)->RemoveAvailableOrientation(arg2);
54101     } catch (std::out_of_range& e) {
54102       {
54103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54104       };
54105     } catch (std::exception& e) {
54106       {
54107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54108       };
54109     } catch (...) {
54110       {
54111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54112       };
54113     }
54114   }
54115 }
54116
54117
54118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54119   Dali::Window *arg1 = (Dali::Window *) 0 ;
54120   Dali::Window::WindowOrientation arg2 ;
54121
54122   arg1 = (Dali::Window *)jarg1;
54123   arg2 = (Dali::Window::WindowOrientation)jarg2;
54124   {
54125     try {
54126       (arg1)->SetPreferredOrientation(arg2);
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (...) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54138       };
54139     }
54140   }
54141 }
54142
54143
54144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54145   int jresult ;
54146   Dali::Window *arg1 = (Dali::Window *) 0 ;
54147   Dali::Window::WindowOrientation result;
54148
54149   arg1 = (Dali::Window *)jarg1;
54150   {
54151     try {
54152       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54153     } catch (std::out_of_range& e) {
54154       {
54155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54156       };
54157     } catch (std::exception& e) {
54158       {
54159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54164       };
54165     }
54166   }
54167   jresult = (int)result;
54168   return jresult;
54169 }
54170
54171
54172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54173   void * jresult ;
54174   Dali::Window *arg1 = (Dali::Window *) 0 ;
54175   Dali::DragAndDropDetector result;
54176
54177   arg1 = (Dali::Window *)jarg1;
54178   {
54179     try {
54180       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54181     } catch (std::out_of_range& e) {
54182       {
54183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54184       };
54185     } catch (std::exception& e) {
54186       {
54187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54188       };
54189     } catch (...) {
54190       {
54191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54192       };
54193     }
54194   }
54195   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54196   return jresult;
54197 }
54198
54199
54200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54201   void * jresult ;
54202   Dali::Window *arg1 = (Dali::Window *) 0 ;
54203   Dali::Any result;
54204
54205   arg1 = (Dali::Window *)jarg1;
54206   {
54207     try {
54208       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54209     } catch (std::out_of_range& e) {
54210       {
54211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54212       };
54213     } catch (std::exception& e) {
54214       {
54215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (...) {
54218       {
54219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54220       };
54221     }
54222   }
54223   jresult = new Dali::Any((const Dali::Any &)result);
54224   return jresult;
54225 }
54226
54227
54228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54229   void * jresult ;
54230   Dali::Window arg1 ;
54231   Dali::Window *argp1 ;
54232   Dali::DevelWindow::FocusSignalType *result = 0 ;
54233
54234   argp1 = (Dali::Window *)jarg1;
54235   if (!argp1) {
54236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54237     return 0;
54238   }
54239   arg1 = *argp1;
54240   {
54241     try {
54242       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54243     } catch (std::out_of_range& e) {
54244       {
54245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54246       };
54247     } catch (std::exception& e) {
54248       {
54249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (...) {
54252       {
54253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54254       };
54255     }
54256   }
54257   jresult = (void *)result;
54258   return jresult;
54259 }
54260
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54263   Dali::Window arg1 ;
54264   bool arg2 ;
54265   Dali::Window *argp1 ;
54266
54267   argp1 = (Dali::Window *)jarg1;
54268   if (!argp1) {
54269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54270     return ;
54271   }
54272   arg1 = *argp1;
54273   arg2 = jarg2 ? true : false;
54274   {
54275     try {
54276       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54284       };
54285     } catch (...) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54288       };
54289     }
54290   }
54291 }
54292
54293
54294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54295   unsigned int jresult ;
54296   Dali::Window arg1 ;
54297   Dali::Window *argp1 ;
54298   bool result;
54299
54300   argp1 = (Dali::Window *)jarg1;
54301   if (!argp1) {
54302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54303     return 0;
54304   }
54305   arg1 = *argp1;
54306   {
54307     try {
54308       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (...) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54320       };
54321     }
54322   }
54323   jresult = result;
54324   return jresult;
54325 }
54326
54327
54328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54329   Dali::Window arg1 ;
54330   Dali::Window *argp1 ;
54331
54332   argp1 = (Dali::Window *)jarg1;
54333   if (!argp1) {
54334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54335     return ;
54336   }
54337   arg1 = *argp1;
54338   {
54339     try {
54340       Dali::DevelWindow::Show(arg1);
54341     } catch (std::out_of_range& e) {
54342       {
54343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54344       };
54345     } catch (std::exception& e) {
54346       {
54347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54348       };
54349     } catch (...) {
54350       {
54351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54352       };
54353     }
54354   }
54355 }
54356
54357
54358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54359   Dali::Window arg1 ;
54360   Dali::Window *argp1 ;
54361
54362   argp1 = (Dali::Window *)jarg1;
54363   if (!argp1) {
54364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54365     return ;
54366   }
54367   arg1 = *argp1;
54368   {
54369     try {
54370       Dali::DevelWindow::Hide(arg1);
54371     } catch (std::out_of_range& e) {
54372       {
54373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54374       };
54375     } catch (std::exception& e) {
54376       {
54377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54378       };
54379     } catch (...) {
54380       {
54381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54382       };
54383     }
54384   }
54385 }
54386
54387
54388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54389   unsigned int jresult ;
54390   Dali::Window arg1 ;
54391   Dali::Window *argp1 ;
54392   bool result;
54393
54394   argp1 = (Dali::Window *)jarg1;
54395   if (!argp1) {
54396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54397     return 0;
54398   }
54399   arg1 = *argp1;
54400   {
54401     try {
54402       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54403     } catch (std::out_of_range& e) {
54404       {
54405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54406       };
54407     } catch (std::exception& e) {
54408       {
54409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54410       };
54411     } catch (...) {
54412       {
54413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54414       };
54415     }
54416   }
54417   jresult = result;
54418   return jresult;
54419 }
54420
54421
54422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54423   unsigned int jresult ;
54424   Dali::Window arg1 ;
54425   Dali::Window *argp1 ;
54426   unsigned int result;
54427
54428   argp1 = (Dali::Window *)jarg1;
54429   if (!argp1) {
54430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54431     return 0;
54432   }
54433   arg1 = *argp1;
54434   {
54435     try {
54436       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54437     } catch (std::out_of_range& e) {
54438       {
54439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54440       };
54441     } catch (std::exception& e) {
54442       {
54443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54444       };
54445     } catch (...) {
54446       {
54447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54448       };
54449     }
54450   }
54451   jresult = result;
54452   return jresult;
54453 }
54454
54455
54456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54457   char * jresult ;
54458   Dali::Window arg1 ;
54459   unsigned int arg2 ;
54460   Dali::Window *argp1 ;
54461   std::string result;
54462
54463   argp1 = (Dali::Window *)jarg1;
54464   if (!argp1) {
54465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54466     return 0;
54467   }
54468   arg1 = *argp1;
54469   arg2 = (unsigned int)jarg2;
54470   {
54471     try {
54472       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54484       };
54485     }
54486   }
54487   jresult = SWIG_csharp_string_callback((&result)->c_str());
54488   return jresult;
54489 }
54490
54491
54492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54493   unsigned int jresult ;
54494   Dali::Window arg1 ;
54495   std::string *arg2 = 0 ;
54496   std::string *arg3 = 0 ;
54497   Dali::Window *argp1 ;
54498   unsigned int result;
54499
54500   argp1 = (Dali::Window *)jarg1;
54501   if (!argp1) {
54502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54503     return 0;
54504   }
54505   arg1 = *argp1;
54506   if (!jarg2) {
54507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54508     return 0;
54509   }
54510   std::string arg2_str(jarg2);
54511   arg2 = &arg2_str;
54512   if (!jarg3) {
54513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54514     return 0;
54515   }
54516   std::string arg3_str(jarg3);
54517   arg3 = &arg3_str;
54518   {
54519     try {
54520       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54521     } catch (std::out_of_range& e) {
54522       {
54523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (std::exception& e) {
54526       {
54527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54528       };
54529     } catch (...) {
54530       {
54531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54532       };
54533     }
54534   }
54535   jresult = result;
54536
54537   //argout typemap for const std::string&
54538
54539
54540   //argout typemap for const std::string&
54541
54542   return jresult;
54543 }
54544
54545
54546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54547   unsigned int jresult ;
54548   Dali::Window arg1 ;
54549   unsigned int arg2 ;
54550   Dali::Window *argp1 ;
54551   bool result;
54552
54553   argp1 = (Dali::Window *)jarg1;
54554   if (!argp1) {
54555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54556     return 0;
54557   }
54558   arg1 = *argp1;
54559   arg2 = (unsigned int)jarg2;
54560   {
54561     try {
54562       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54563     } catch (std::out_of_range& e) {
54564       {
54565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54566       };
54567     } catch (std::exception& e) {
54568       {
54569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54570       };
54571     } catch (...) {
54572       {
54573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54574       };
54575     }
54576   }
54577   jresult = result;
54578   return jresult;
54579 }
54580
54581
54582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54583   unsigned int jresult ;
54584   Dali::Window arg1 ;
54585   unsigned int arg2 ;
54586   std::string *arg3 = 0 ;
54587   Dali::Window *argp1 ;
54588   bool result;
54589
54590   argp1 = (Dali::Window *)jarg1;
54591   if (!argp1) {
54592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54593     return 0;
54594   }
54595   arg1 = *argp1;
54596   arg2 = (unsigned int)jarg2;
54597   if (!jarg3) {
54598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54599     return 0;
54600   }
54601   std::string arg3_str(jarg3);
54602   arg3 = &arg3_str;
54603   {
54604     try {
54605       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54606     } catch (std::out_of_range& e) {
54607       {
54608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54609       };
54610     } catch (std::exception& e) {
54611       {
54612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54613       };
54614     } catch (...) {
54615       {
54616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54617       };
54618     }
54619   }
54620   jresult = result;
54621
54622   //argout typemap for const std::string&
54623
54624   return jresult;
54625 }
54626
54627
54628 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54629   char * jresult ;
54630   Dali::Window arg1 ;
54631   unsigned int arg2 ;
54632   Dali::Window *argp1 ;
54633   std::string result;
54634
54635   argp1 = (Dali::Window *)jarg1;
54636   if (!argp1) {
54637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54638     return 0;
54639   }
54640   arg1 = *argp1;
54641   arg2 = (unsigned int)jarg2;
54642   {
54643     try {
54644       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54645     } catch (std::out_of_range& e) {
54646       {
54647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54648       };
54649     } catch (std::exception& e) {
54650       {
54651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54652       };
54653     } catch (...) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54656       };
54657     }
54658   }
54659   jresult = SWIG_csharp_string_callback((&result)->c_str());
54660   return jresult;
54661 }
54662
54663
54664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54665   unsigned int jresult ;
54666   Dali::Window arg1 ;
54667   std::string *arg2 = 0 ;
54668   Dali::Window *argp1 ;
54669   unsigned int result;
54670
54671   argp1 = (Dali::Window *)jarg1;
54672   if (!argp1) {
54673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54674     return 0;
54675   }
54676   arg1 = *argp1;
54677   if (!jarg2) {
54678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54679     return 0;
54680   }
54681   std::string arg2_str(jarg2);
54682   arg2 = &arg2_str;
54683   {
54684     try {
54685       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = result;
54701
54702   //argout typemap for const std::string&
54703
54704   return jresult;
54705 }
54706
54707
54708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54709   Dali::Window arg1 ;
54710   Dali::Rect< int > *arg2 = 0 ;
54711   Dali::Window *argp1 ;
54712
54713   argp1 = (Dali::Window *)jarg1;
54714   if (!argp1) {
54715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54716     return ;
54717   }
54718   arg1 = *argp1;
54719   arg2 = (Dali::Rect< int > *)jarg2;
54720   if (!arg2) {
54721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54722     return ;
54723   }
54724   {
54725     try {
54726       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54734       };
54735     } catch (...) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54738       };
54739     }
54740   }
54741 }
54742
54743
54744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54745   Dali::Window arg1 ;
54746   Dali::DevelWindow::Type arg2 ;
54747   Dali::Window *argp1 ;
54748
54749   argp1 = (Dali::Window *)jarg1;
54750   if (!argp1) {
54751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54752     return ;
54753   }
54754   arg1 = *argp1;
54755   arg2 = (Dali::DevelWindow::Type)jarg2;
54756   {
54757     try {
54758       Dali::DevelWindow::SetType(arg1,arg2);
54759     } catch (std::out_of_range& e) {
54760       {
54761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54762       };
54763     } catch (std::exception& e) {
54764       {
54765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54766       };
54767     } catch (...) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54770       };
54771     }
54772   }
54773 }
54774
54775
54776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54777   int jresult ;
54778   Dali::Window arg1 ;
54779   Dali::Window *argp1 ;
54780   Dali::DevelWindow::Type result;
54781
54782   argp1 = (Dali::Window *)jarg1;
54783   if (!argp1) {
54784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54785     return 0;
54786   }
54787   arg1 = *argp1;
54788   {
54789     try {
54790       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54791     } catch (std::out_of_range& e) {
54792       {
54793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54794       };
54795     } catch (std::exception& e) {
54796       {
54797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54798       };
54799     } catch (...) {
54800       {
54801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54802       };
54803     }
54804   }
54805   jresult = (int)result;
54806   return jresult;
54807 }
54808
54809
54810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54811   unsigned int jresult ;
54812   Dali::Window arg1 ;
54813   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54814   Dali::Window *argp1 ;
54815   bool result;
54816
54817   argp1 = (Dali::Window *)jarg1;
54818   if (!argp1) {
54819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54820     return 0;
54821   }
54822   arg1 = *argp1;
54823   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54824   {
54825     try {
54826       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54827     } catch (std::out_of_range& e) {
54828       {
54829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54830       };
54831     } catch (std::exception& e) {
54832       {
54833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54834       };
54835     } catch (...) {
54836       {
54837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54838       };
54839     }
54840   }
54841   jresult = result;
54842   return jresult;
54843 }
54844
54845
54846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54847   int jresult ;
54848   Dali::Window arg1 ;
54849   Dali::Window *argp1 ;
54850   Dali::DevelWindow::NotificationLevel::Type result;
54851
54852   argp1 = (Dali::Window *)jarg1;
54853   if (!argp1) {
54854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54855     return 0;
54856   }
54857   arg1 = *argp1;
54858   {
54859     try {
54860       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54861     } catch (std::out_of_range& e) {
54862       {
54863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54864       };
54865     } catch (std::exception& e) {
54866       {
54867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54868       };
54869     } catch (...) {
54870       {
54871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54872       };
54873     }
54874   }
54875   jresult = (int)result;
54876   return jresult;
54877 }
54878
54879
54880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54881   Dali::Window arg1 ;
54882   bool arg2 ;
54883   Dali::Window *argp1 ;
54884
54885   argp1 = (Dali::Window *)jarg1;
54886   if (!argp1) {
54887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54888     return ;
54889   }
54890   arg1 = *argp1;
54891   arg2 = jarg2 ? true : false;
54892   {
54893     try {
54894       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54895     } catch (std::out_of_range& e) {
54896       {
54897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54898       };
54899     } catch (std::exception& e) {
54900       {
54901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54902       };
54903     } catch (...) {
54904       {
54905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54906       };
54907     }
54908   }
54909 }
54910
54911
54912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
54913   unsigned int jresult ;
54914   Dali::Window arg1 ;
54915   Dali::Window *argp1 ;
54916   bool result;
54917
54918   argp1 = (Dali::Window *)jarg1;
54919   if (!argp1) {
54920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54921     return 0;
54922   }
54923   arg1 = *argp1;
54924   {
54925     try {
54926       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
54927     } catch (std::out_of_range& e) {
54928       {
54929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54930       };
54931     } catch (std::exception& e) {
54932       {
54933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54934       };
54935     } catch (...) {
54936       {
54937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54938       };
54939     }
54940   }
54941   jresult = result;
54942   return jresult;
54943 }
54944
54945
54946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
54947   unsigned int jresult ;
54948   Dali::Window arg1 ;
54949   Dali::DevelWindow::ScreenMode::Type arg2 ;
54950   Dali::Window *argp1 ;
54951   bool result;
54952
54953   argp1 = (Dali::Window *)jarg1;
54954   if (!argp1) {
54955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54956     return 0;
54957   }
54958   arg1 = *argp1;
54959   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
54960   {
54961     try {
54962       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (...) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54974       };
54975     }
54976   }
54977   jresult = result;
54978   return jresult;
54979 }
54980
54981
54982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
54983   int jresult ;
54984   Dali::Window arg1 ;
54985   Dali::Window *argp1 ;
54986   Dali::DevelWindow::ScreenMode::Type result;
54987
54988   argp1 = (Dali::Window *)jarg1;
54989   if (!argp1) {
54990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54991     return 0;
54992   }
54993   arg1 = *argp1;
54994   {
54995     try {
54996       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
54997     } catch (std::out_of_range& e) {
54998       {
54999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55000       };
55001     } catch (std::exception& e) {
55002       {
55003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55004       };
55005     } catch (...) {
55006       {
55007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55008       };
55009     }
55010   }
55011   jresult = (int)result;
55012   return jresult;
55013 }
55014
55015
55016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55017   unsigned int jresult ;
55018   Dali::Window arg1 ;
55019   int arg2 ;
55020   Dali::Window *argp1 ;
55021   bool result;
55022
55023   argp1 = (Dali::Window *)jarg1;
55024   if (!argp1) {
55025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55026     return 0;
55027   }
55028   arg1 = *argp1;
55029   arg2 = (int)jarg2;
55030   {
55031     try {
55032       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55033     } catch (std::out_of_range& e) {
55034       {
55035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55036       };
55037     } catch (std::exception& e) {
55038       {
55039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55040       };
55041     } catch (...) {
55042       {
55043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55044       };
55045     }
55046   }
55047   jresult = result;
55048   return jresult;
55049 }
55050
55051
55052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55053   int jresult ;
55054   Dali::Window arg1 ;
55055   Dali::Window *argp1 ;
55056   int result;
55057
55058   argp1 = (Dali::Window *)jarg1;
55059   if (!argp1) {
55060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55061     return 0;
55062   }
55063   arg1 = *argp1;
55064   {
55065     try {
55066       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55067     } catch (std::out_of_range& e) {
55068       {
55069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55070       };
55071     } catch (std::exception& e) {
55072       {
55073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55074       };
55075     } catch (...) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55078       };
55079     }
55080   }
55081   jresult = result;
55082   return jresult;
55083 }
55084
55085
55086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55087   void * jresult ;
55088   Dali::Application result;
55089
55090   {
55091     try {
55092       result = Dali::Application::New();
55093     } catch (std::out_of_range& e) {
55094       {
55095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55096       };
55097     } catch (std::exception& e) {
55098       {
55099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55100       };
55101     } catch (...) {
55102       {
55103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55104       };
55105     }
55106   }
55107   jresult = new Dali::Application((const Dali::Application &)result);
55108   return jresult;
55109 }
55110
55111
55112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55113   void * jresult ;
55114   int *arg1 = (int *) 0 ;
55115   char ***arg2 ;
55116   Dali::Application result;
55117
55118   {
55119     // Todo generate argv data from the C# args
55120     char **array;         // two dimensional array
55121     int numStrings = 1;     // number of strings
55122     int stringLength = 30;      // max string length.
55123     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55124     argV = array;
55125
55126     // allocate the string data
55127     for( int i=0; i < numStrings; i++)
55128     {
55129       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55130     }
55131     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55132
55133     strcpy( array[0], "dali-csharp-app");
55134
55135     arg1 = &argC;
55136     arg2 = &argV;
55137   }
55138   {
55139     try {
55140       result = Dali::Application::New(arg1,arg2);
55141     } catch (std::out_of_range& e) {
55142       {
55143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55144       };
55145     } catch (std::exception& e) {
55146       {
55147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55148       };
55149     } catch (...) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55152       };
55153     }
55154   }
55155   jresult = new Dali::Application((const Dali::Application &)result);
55156   return jresult;
55157 }
55158
55159
55160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55161   void * jresult ;
55162   int *arg1 = (int *) 0 ;
55163   char ***arg2 ;
55164   std::string *arg3 = 0 ;
55165   Dali::Application result;
55166
55167   {
55168     // Todo generate argv data from the C# args
55169     char **array;         // two dimensional array
55170     int numStrings = 1;     // number of strings
55171     int stringLength = 30;      // max string length.
55172     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55173     argV = array;
55174
55175     // allocate the string data
55176     for( int i=0; i < numStrings; i++)
55177     {
55178       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55179     }
55180     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55181
55182     strcpy( array[0], "dali-csharp-app");
55183
55184     arg1 = &argC;
55185     arg2 = &argV;
55186   }
55187   if (!jarg3) {
55188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55189     return 0;
55190   }
55191   std::string arg3_str(jarg3);
55192   arg3 = &arg3_str;
55193   {
55194     try {
55195       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55207       };
55208     }
55209   }
55210   jresult = new Dali::Application((const Dali::Application &)result);
55211
55212   //argout typemap for const std::string&
55213
55214   return jresult;
55215 }
55216
55217
55218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55219   void * jresult ;
55220   int *arg1 = (int *) 0 ;
55221   char ***arg2 ;
55222   std::string *arg3 = 0 ;
55223   Dali::Application::WINDOW_MODE arg4 ;
55224   Dali::Application result;
55225
55226   {
55227     // Todo generate argv data from the C# args
55228     char **array;         // two dimensional array
55229     int numStrings = 1;     // number of strings
55230     int stringLength = 30;      // max string length.
55231     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55232     argV = array;
55233
55234     // allocate the string data
55235     for( int i=0; i < numStrings; i++)
55236     {
55237       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55238     }
55239     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55240
55241     strcpy( array[0], "dali-csharp-app");
55242
55243     arg1 = &argC;
55244     arg2 = &argV;
55245   }
55246   if (!jarg3) {
55247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55248     return 0;
55249   }
55250   std::string arg3_str(jarg3);
55251   arg3 = &arg3_str;
55252   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55253   {
55254     try {
55255       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55256     } catch (std::out_of_range& e) {
55257       {
55258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (std::exception& e) {
55261       {
55262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55263       };
55264     } catch (...) {
55265       {
55266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55267       };
55268     }
55269   }
55270   jresult = new Dali::Application((const Dali::Application &)result);
55271
55272   //argout typemap for const std::string&
55273
55274   return jresult;
55275 }
55276
55277
55278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55279   void * jresult ;
55280   Dali::Application *result = 0 ;
55281
55282   {
55283     try {
55284       result = (Dali::Application *)new Dali::Application();
55285     } catch (std::out_of_range& e) {
55286       {
55287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55288       };
55289     } catch (std::exception& e) {
55290       {
55291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55292       };
55293     } catch (...) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55296       };
55297     }
55298   }
55299   jresult = (void *)result;
55300   return jresult;
55301 }
55302
55303
55304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55305   void * jresult ;
55306   Dali::Application *arg1 = 0 ;
55307   Dali::Application *result = 0 ;
55308
55309   arg1 = (Dali::Application *)jarg1;
55310   if (!arg1) {
55311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55312     return 0;
55313   }
55314   {
55315     try {
55316       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55317     } catch (std::out_of_range& e) {
55318       {
55319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55320       };
55321     } catch (std::exception& e) {
55322       {
55323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55324       };
55325     } catch (...) {
55326       {
55327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55328       };
55329     }
55330   }
55331   jresult = (void *)result;
55332   return jresult;
55333 }
55334
55335
55336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55337   void * jresult ;
55338   Dali::Application *arg1 = (Dali::Application *) 0 ;
55339   Dali::Application *arg2 = 0 ;
55340   Dali::Application *result = 0 ;
55341
55342   arg1 = (Dali::Application *)jarg1;
55343   arg2 = (Dali::Application *)jarg2;
55344   if (!arg2) {
55345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55346     return 0;
55347   }
55348   {
55349     try {
55350       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55351     } catch (std::out_of_range& e) {
55352       {
55353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (std::exception& e) {
55356       {
55357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55358       };
55359     } catch (...) {
55360       {
55361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55362       };
55363     }
55364   }
55365   jresult = (void *)result;
55366   return jresult;
55367 }
55368
55369
55370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55371   Dali::Application *arg1 = (Dali::Application *) 0 ;
55372
55373   arg1 = (Dali::Application *)jarg1;
55374   {
55375     try {
55376       delete arg1;
55377     } catch (std::out_of_range& e) {
55378       {
55379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55380       };
55381     } catch (std::exception& e) {
55382       {
55383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55384       };
55385     } catch (...) {
55386       {
55387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55388       };
55389     }
55390   }
55391 }
55392
55393
55394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55395   Dali::Application *arg1 = (Dali::Application *) 0 ;
55396
55397   arg1 = (Dali::Application *)jarg1;
55398   {
55399     try {
55400       (arg1)->MainLoop();
55401     } catch (std::out_of_range& e) {
55402       {
55403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55404       };
55405     } catch (std::exception& e) {
55406       {
55407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55408       };
55409     } catch (...) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55412       };
55413     }
55414   }
55415 }
55416
55417
55418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55419   Dali::Application *arg1 = (Dali::Application *) 0 ;
55420   Configuration::ContextLoss arg2 ;
55421   Configuration::ContextLoss *argp2 ;
55422
55423   arg1 = (Dali::Application *)jarg1;
55424   argp2 = (Configuration::ContextLoss *)jarg2;
55425   if (!argp2) {
55426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55427     return ;
55428   }
55429   arg2 = *argp2;
55430   {
55431     try {
55432       (arg1)->MainLoop(arg2);
55433     } catch (std::out_of_range& e) {
55434       {
55435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55436       };
55437     } catch (std::exception& e) {
55438       {
55439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55440       };
55441     } catch (...) {
55442       {
55443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55444       };
55445     }
55446   }
55447 }
55448
55449
55450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55451   Dali::Application *arg1 = (Dali::Application *) 0 ;
55452
55453   arg1 = (Dali::Application *)jarg1;
55454   {
55455     try {
55456       (arg1)->Lower();
55457     } catch (std::out_of_range& e) {
55458       {
55459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55460       };
55461     } catch (std::exception& e) {
55462       {
55463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55464       };
55465     } catch (...) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55468       };
55469     }
55470   }
55471 }
55472
55473
55474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55475   Dali::Application *arg1 = (Dali::Application *) 0 ;
55476
55477   arg1 = (Dali::Application *)jarg1;
55478   {
55479     try {
55480       (arg1)->Quit();
55481     } catch (std::out_of_range& e) {
55482       {
55483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55484       };
55485     } catch (std::exception& e) {
55486       {
55487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55488       };
55489     } catch (...) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55492       };
55493     }
55494   }
55495 }
55496
55497
55498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55499   unsigned int jresult ;
55500   Dali::Application *arg1 = (Dali::Application *) 0 ;
55501   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55502   bool result;
55503
55504   arg1 = (Dali::Application *)jarg1;
55505   arg2 = (Dali::CallbackBase *)jarg2;
55506   {
55507     try {
55508       result = (bool)(arg1)->AddIdle(arg2);
55509     } catch (std::out_of_range& e) {
55510       {
55511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (std::exception& e) {
55514       {
55515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55516       };
55517     } catch (...) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55520       };
55521     }
55522   }
55523   jresult = result;
55524   return jresult;
55525 }
55526
55527
55528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55529   void * jresult ;
55530   Dali::Application *arg1 = (Dali::Application *) 0 ;
55531   Dali::Window result;
55532
55533   arg1 = (Dali::Application *)jarg1;
55534   {
55535     try {
55536       result = (arg1)->GetWindow();
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55548       };
55549     }
55550   }
55551   jresult = new Dali::Window((const Dali::Window &)result);
55552   return jresult;
55553 }
55554
55555
55556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55557   Dali::Application *arg1 = (Dali::Application *) 0 ;
55558   Dali::PositionSize arg2 ;
55559   std::string *arg3 = 0 ;
55560   Dali::PositionSize *argp2 ;
55561
55562   arg1 = (Dali::Application *)jarg1;
55563   argp2 = (Dali::PositionSize *)jarg2;
55564   if (!argp2) {
55565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55566     return ;
55567   }
55568   arg2 = *argp2;
55569   if (!jarg3) {
55570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55571     return ;
55572   }
55573   std::string arg3_str(jarg3);
55574   arg3 = &arg3_str;
55575   {
55576     try {
55577       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55578     } catch (std::out_of_range& e) {
55579       {
55580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55581       };
55582     } catch (std::exception& e) {
55583       {
55584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55585       };
55586     } catch (...) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55589       };
55590     }
55591   }
55592
55593   //argout typemap for const std::string&
55594
55595 }
55596
55597
55598 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55599   char * jresult ;
55600   std::string result;
55601
55602   {
55603     try {
55604       result = Dali::Application::GetResourcePath();
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55612       };
55613     } catch (...) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55616       };
55617     }
55618   }
55619   jresult = SWIG_csharp_string_callback((&result)->c_str());
55620   return jresult;
55621 }
55622
55623
55624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55625   Dali::Application *arg1 = (Dali::Application *) 0 ;
55626   Dali::ViewMode arg2 ;
55627
55628   arg1 = (Dali::Application *)jarg1;
55629   arg2 = (Dali::ViewMode)jarg2;
55630   {
55631     try {
55632       (arg1)->SetViewMode(arg2);
55633     } catch (std::out_of_range& e) {
55634       {
55635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55636       };
55637     } catch (std::exception& e) {
55638       {
55639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55640       };
55641     } catch (...) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55644       };
55645     }
55646   }
55647 }
55648
55649
55650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55651   int jresult ;
55652   Dali::Application *arg1 = (Dali::Application *) 0 ;
55653   Dali::ViewMode result;
55654
55655   arg1 = (Dali::Application *)jarg1;
55656   {
55657     try {
55658       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55659     } catch (std::out_of_range& e) {
55660       {
55661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55662       };
55663     } catch (std::exception& e) {
55664       {
55665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55666       };
55667     } catch (...) {
55668       {
55669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55670       };
55671     }
55672   }
55673   jresult = (int)result;
55674   return jresult;
55675 }
55676
55677
55678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55679   Dali::Application *arg1 = (Dali::Application *) 0 ;
55680   float arg2 ;
55681
55682   arg1 = (Dali::Application *)jarg1;
55683   arg2 = (float)jarg2;
55684   {
55685     try {
55686       (arg1)->SetStereoBase(arg2);
55687     } catch (std::out_of_range& e) {
55688       {
55689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55690       };
55691     } catch (std::exception& e) {
55692       {
55693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55694       };
55695     } catch (...) {
55696       {
55697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55698       };
55699     }
55700   }
55701 }
55702
55703
55704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55705   float jresult ;
55706   Dali::Application *arg1 = (Dali::Application *) 0 ;
55707   float result;
55708
55709   arg1 = (Dali::Application *)jarg1;
55710   {
55711     try {
55712       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55720       };
55721     } catch (...) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55724       };
55725     }
55726   }
55727   jresult = result;
55728   return jresult;
55729 }
55730
55731
55732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55733   void * jresult ;
55734   Dali::Application *arg1 = (Dali::Application *) 0 ;
55735   Dali::Application::AppSignalType *result = 0 ;
55736
55737   arg1 = (Dali::Application *)jarg1;
55738   {
55739     try {
55740       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755   jresult = (void *)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55761   void * jresult ;
55762   Dali::Application *arg1 = (Dali::Application *) 0 ;
55763   Dali::Application::AppSignalType *result = 0 ;
55764
55765   arg1 = (Dali::Application *)jarg1;
55766   {
55767     try {
55768       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55769     } catch (std::out_of_range& e) {
55770       {
55771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55772       };
55773     } catch (std::exception& e) {
55774       {
55775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55776       };
55777     } catch (...) {
55778       {
55779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55780       };
55781     }
55782   }
55783   jresult = (void *)result;
55784   return jresult;
55785 }
55786
55787
55788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55789   void * jresult ;
55790   Dali::Application *arg1 = (Dali::Application *) 0 ;
55791   Dali::Application::AppSignalType *result = 0 ;
55792
55793   arg1 = (Dali::Application *)jarg1;
55794   {
55795     try {
55796       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55797     } catch (std::out_of_range& e) {
55798       {
55799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (std::exception& e) {
55802       {
55803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55804       };
55805     } catch (...) {
55806       {
55807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55808       };
55809     }
55810   }
55811   jresult = (void *)result;
55812   return jresult;
55813 }
55814
55815
55816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55817   void * jresult ;
55818   Dali::Application *arg1 = (Dali::Application *) 0 ;
55819   Dali::Application::AppSignalType *result = 0 ;
55820
55821   arg1 = (Dali::Application *)jarg1;
55822   {
55823     try {
55824       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55825     } catch (std::out_of_range& e) {
55826       {
55827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55828       };
55829     } catch (std::exception& e) {
55830       {
55831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55832       };
55833     } catch (...) {
55834       {
55835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55836       };
55837     }
55838   }
55839   jresult = (void *)result;
55840   return jresult;
55841 }
55842
55843
55844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55845   void * jresult ;
55846   Dali::Application *arg1 = (Dali::Application *) 0 ;
55847   Dali::Application::AppSignalType *result = 0 ;
55848
55849   arg1 = (Dali::Application *)jarg1;
55850   {
55851     try {
55852       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55853     } catch (std::out_of_range& e) {
55854       {
55855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55856       };
55857     } catch (std::exception& e) {
55858       {
55859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55860       };
55861     } catch (...) {
55862       {
55863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55864       };
55865     }
55866   }
55867   jresult = (void *)result;
55868   return jresult;
55869 }
55870
55871
55872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55873   void * jresult ;
55874   Dali::Application *arg1 = (Dali::Application *) 0 ;
55875   Dali::Application::AppSignalType *result = 0 ;
55876
55877   arg1 = (Dali::Application *)jarg1;
55878   {
55879     try {
55880       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55881     } catch (std::out_of_range& e) {
55882       {
55883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (std::exception& e) {
55886       {
55887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55888       };
55889     } catch (...) {
55890       {
55891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55892       };
55893     }
55894   }
55895   jresult = (void *)result;
55896   return jresult;
55897 }
55898
55899
55900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55901   void * jresult ;
55902   Dali::Application *arg1 = (Dali::Application *) 0 ;
55903   Dali::Application::AppControlSignalType *result = 0 ;
55904
55905   arg1 = (Dali::Application *)jarg1;
55906   {
55907     try {
55908       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55909     } catch (std::out_of_range& e) {
55910       {
55911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (std::exception& e) {
55914       {
55915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55916       };
55917     } catch (...) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55920       };
55921     }
55922   }
55923   jresult = (void *)result;
55924   return jresult;
55925 }
55926
55927
55928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55929   void * jresult ;
55930   Dali::Application *arg1 = (Dali::Application *) 0 ;
55931   Dali::Application::AppSignalType *result = 0 ;
55932
55933   arg1 = (Dali::Application *)jarg1;
55934   {
55935     try {
55936       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55937     } catch (std::out_of_range& e) {
55938       {
55939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (std::exception& e) {
55942       {
55943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55944       };
55945     } catch (...) {
55946       {
55947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55948       };
55949     }
55950   }
55951   jresult = (void *)result;
55952   return jresult;
55953 }
55954
55955
55956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55957   void * jresult ;
55958   Dali::Application *arg1 = (Dali::Application *) 0 ;
55959   Dali::Application::AppSignalType *result = 0 ;
55960
55961   arg1 = (Dali::Application *)jarg1;
55962   {
55963     try {
55964       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55965     } catch (std::out_of_range& e) {
55966       {
55967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (std::exception& e) {
55970       {
55971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55972       };
55973     } catch (...) {
55974       {
55975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55976       };
55977     }
55978   }
55979   jresult = (void *)result;
55980   return jresult;
55981 }
55982
55983
55984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55985   void * jresult ;
55986   Dali::Application *arg1 = (Dali::Application *) 0 ;
55987   Dali::Application::AppSignalType *result = 0 ;
55988
55989   arg1 = (Dali::Application *)jarg1;
55990   {
55991     try {
55992       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55993     } catch (std::out_of_range& e) {
55994       {
55995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55996       };
55997     } catch (std::exception& e) {
55998       {
55999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56000       };
56001     } catch (...) {
56002       {
56003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56004       };
56005     }
56006   }
56007   jresult = (void *)result;
56008   return jresult;
56009 }
56010
56011
56012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56013   void * jresult ;
56014   Dali::Application *arg1 = (Dali::Application *) 0 ;
56015   Dali::Application::AppSignalType *result = 0 ;
56016
56017   arg1 = (Dali::Application *)jarg1;
56018   {
56019     try {
56020       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56021     } catch (std::out_of_range& e) {
56022       {
56023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56024       };
56025     } catch (std::exception& e) {
56026       {
56027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56028       };
56029     } catch (...) {
56030       {
56031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56032       };
56033     }
56034   }
56035   jresult = (void *)result;
56036   return jresult;
56037 }
56038
56039
56040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56041   unsigned int jresult ;
56042   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56043   bool result;
56044
56045   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56046   {
56047     try {
56048       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56060       };
56061     }
56062   }
56063   jresult = result;
56064   return jresult;
56065 }
56066
56067
56068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56069   unsigned long jresult ;
56070   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56071   std::size_t result;
56072
56073   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56074   {
56075     try {
56076       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56077     } catch (std::out_of_range& e) {
56078       {
56079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (std::exception& e) {
56082       {
56083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (...) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56088       };
56089     }
56090   }
56091   jresult = (unsigned long)result;
56092   return jresult;
56093 }
56094
56095
56096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56097   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56098   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56099
56100   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56101   arg2 = (void (*)(Dali::Application &))jarg2;
56102   {
56103     try {
56104       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56105     } catch (std::out_of_range& e) {
56106       {
56107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56108       };
56109     } catch (std::exception& e) {
56110       {
56111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56112       };
56113     } catch (...) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56116       };
56117     }
56118   }
56119 }
56120
56121
56122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56123   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56124   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56125
56126   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56127   arg2 = (void (*)(Dali::Application &))jarg2;
56128   {
56129     try {
56130       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56131     } catch (std::out_of_range& e) {
56132       {
56133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56134       };
56135     } catch (std::exception& e) {
56136       {
56137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56138       };
56139     } catch (...) {
56140       {
56141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56142       };
56143     }
56144   }
56145 }
56146
56147
56148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56149   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56150   Dali::Application *arg2 = 0 ;
56151
56152   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56153   arg2 = (Dali::Application *)jarg2;
56154   if (!arg2) {
56155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56156     return ;
56157   }
56158   {
56159     try {
56160       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56161     } catch (std::out_of_range& e) {
56162       {
56163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56164       };
56165     } catch (std::exception& e) {
56166       {
56167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56168       };
56169     } catch (...) {
56170       {
56171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56172       };
56173     }
56174   }
56175 }
56176
56177
56178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56179   void * jresult ;
56180   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56181
56182   {
56183     try {
56184       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = (void *)result;
56200   return jresult;
56201 }
56202
56203
56204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56205   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56206
56207   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56208   {
56209     try {
56210       delete arg1;
56211     } catch (std::out_of_range& e) {
56212       {
56213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (std::exception& e) {
56216       {
56217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56222       };
56223     }
56224   }
56225 }
56226
56227
56228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56229   unsigned int jresult ;
56230   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56231   bool result;
56232
56233   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56234   {
56235     try {
56236       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (...) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56248       };
56249     }
56250   }
56251   jresult = result;
56252   return jresult;
56253 }
56254
56255
56256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56257   unsigned long jresult ;
56258   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56259   std::size_t result;
56260
56261   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56262   {
56263     try {
56264       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56265     } catch (std::out_of_range& e) {
56266       {
56267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (std::exception& e) {
56270       {
56271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279   jresult = (unsigned long)result;
56280   return jresult;
56281 }
56282
56283
56284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56285   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56286   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56287
56288   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56289   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56290   {
56291     try {
56292       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56300       };
56301     } catch (...) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56304       };
56305     }
56306   }
56307 }
56308
56309
56310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56311   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56312   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56313
56314   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56315   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56316   {
56317     try {
56318       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56319     } catch (std::out_of_range& e) {
56320       {
56321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56322       };
56323     } catch (std::exception& e) {
56324       {
56325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56326       };
56327     } catch (...) {
56328       {
56329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56330       };
56331     }
56332   }
56333 }
56334
56335
56336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56337   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56338   Dali::Application *arg2 = 0 ;
56339   void *arg3 = (void *) 0 ;
56340
56341   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56342   arg2 = (Dali::Application *)jarg2;
56343   if (!arg2) {
56344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56345     return ;
56346   }
56347   arg3 = jarg3;
56348   {
56349     try {
56350       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56351     } catch (std::out_of_range& e) {
56352       {
56353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56354       };
56355     } catch (std::exception& e) {
56356       {
56357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56358       };
56359     } catch (...) {
56360       {
56361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56362       };
56363     }
56364   }
56365 }
56366
56367
56368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56369   void * jresult ;
56370   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56371
56372   {
56373     try {
56374       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56375     } catch (std::out_of_range& e) {
56376       {
56377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56378       };
56379     } catch (std::exception& e) {
56380       {
56381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56382       };
56383     } catch (...) {
56384       {
56385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56386       };
56387     }
56388   }
56389   jresult = (void *)result;
56390   return jresult;
56391 }
56392
56393
56394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56395   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56396
56397   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56398   {
56399     try {
56400       delete arg1;
56401     } catch (std::out_of_range& e) {
56402       {
56403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56404       };
56405     } catch (std::exception& e) {
56406       {
56407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56408       };
56409     } catch (...) {
56410       {
56411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56412       };
56413     }
56414   }
56415 }
56416
56417
56418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56419   unsigned int jresult ;
56420   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56421   bool result;
56422
56423   arg1 = (Dali::Signal< bool () > *)jarg1;
56424   {
56425     try {
56426       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56427     } catch (std::out_of_range& e) {
56428       {
56429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (std::exception& e) {
56432       {
56433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56434       };
56435     } catch (...) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56438       };
56439     }
56440   }
56441   jresult = result;
56442   return jresult;
56443 }
56444
56445
56446 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56447   unsigned long jresult ;
56448   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56449   std::size_t result;
56450
56451   arg1 = (Dali::Signal< bool () > *)jarg1;
56452   {
56453     try {
56454       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56466       };
56467     }
56468   }
56469   jresult = (unsigned long)result;
56470   return jresult;
56471 }
56472
56473
56474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56475   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56476   bool (*arg2)() = (bool (*)()) 0 ;
56477
56478   arg1 = (Dali::Signal< bool () > *)jarg1;
56479   arg2 = (bool (*)())jarg2;
56480   {
56481     try {
56482       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56483     } catch (std::out_of_range& e) {
56484       {
56485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56486       };
56487     } catch (std::exception& e) {
56488       {
56489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56490       };
56491     } catch (...) {
56492       {
56493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56494       };
56495     }
56496   }
56497 }
56498
56499
56500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56501   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56502   bool (*arg2)() = (bool (*)()) 0 ;
56503
56504   arg1 = (Dali::Signal< bool () > *)jarg1;
56505   arg2 = (bool (*)())jarg2;
56506   {
56507     try {
56508       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56509     } catch (std::out_of_range& e) {
56510       {
56511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56512       };
56513     } catch (std::exception& e) {
56514       {
56515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56516       };
56517     } catch (...) {
56518       {
56519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56520       };
56521     }
56522   }
56523 }
56524
56525
56526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56527   unsigned int jresult ;
56528   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56529   bool result;
56530
56531   arg1 = (Dali::Signal< bool () > *)jarg1;
56532   {
56533     try {
56534       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56542       };
56543     } catch (...) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56546       };
56547     }
56548   }
56549   jresult = result;
56550   return jresult;
56551 }
56552
56553
56554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56555   void * jresult ;
56556   Dali::Signal< bool () > *result = 0 ;
56557
56558   {
56559     try {
56560       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56561     } catch (std::out_of_range& e) {
56562       {
56563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (std::exception& e) {
56566       {
56567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56568       };
56569     } catch (...) {
56570       {
56571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56572       };
56573     }
56574   }
56575   jresult = (void *)result;
56576   return jresult;
56577 }
56578
56579
56580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56581   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56582
56583   arg1 = (Dali::Signal< bool () > *)jarg1;
56584   {
56585     try {
56586       delete arg1;
56587     } catch (std::out_of_range& e) {
56588       {
56589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56590       };
56591     } catch (std::exception& e) {
56592       {
56593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56594       };
56595     } catch (...) {
56596       {
56597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56598       };
56599     }
56600   }
56601 }
56602
56603
56604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56605   unsigned int jresult ;
56606   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56607   bool result;
56608
56609   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56610   {
56611     try {
56612       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (...) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56624       };
56625     }
56626   }
56627   jresult = result;
56628   return jresult;
56629 }
56630
56631
56632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56633   unsigned long jresult ;
56634   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56635   std::size_t result;
56636
56637   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56638   {
56639     try {
56640       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (...) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56652       };
56653     }
56654   }
56655   jresult = (unsigned long)result;
56656   return jresult;
56657 }
56658
56659
56660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56661   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56662   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56663
56664   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56665   arg2 = (void (*)(bool))jarg2;
56666   {
56667     try {
56668       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56669     } catch (std::out_of_range& e) {
56670       {
56671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56672       };
56673     } catch (std::exception& e) {
56674       {
56675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56676       };
56677     } catch (...) {
56678       {
56679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56680       };
56681     }
56682   }
56683 }
56684
56685
56686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56687   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56688   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56689
56690   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56691   arg2 = (void (*)(bool))jarg2;
56692   {
56693     try {
56694       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56695     } catch (std::out_of_range& e) {
56696       {
56697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56698       };
56699     } catch (std::exception& e) {
56700       {
56701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56702       };
56703     } catch (...) {
56704       {
56705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56706       };
56707     }
56708   }
56709 }
56710
56711
56712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56713   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56714   bool arg2 ;
56715
56716   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56717   arg2 = jarg2 ? true : false;
56718   {
56719     try {
56720       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56721     } catch (std::out_of_range& e) {
56722       {
56723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56724       };
56725     } catch (std::exception& e) {
56726       {
56727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56732       };
56733     }
56734   }
56735 }
56736
56737
56738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56739   void * jresult ;
56740   Dali::Signal< void (bool) > *result = 0 ;
56741
56742   {
56743     try {
56744       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56745     } catch (std::out_of_range& e) {
56746       {
56747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56748       };
56749     } catch (std::exception& e) {
56750       {
56751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56752       };
56753     } catch (...) {
56754       {
56755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56756       };
56757     }
56758   }
56759   jresult = (void *)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56765   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56766
56767   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56768   {
56769     try {
56770       delete arg1;
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56782       };
56783     }
56784   }
56785 }
56786
56787
56788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56789   int jresult ;
56790   int result;
56791
56792   {
56793     try {
56794       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56795     } catch (std::out_of_range& e) {
56796       {
56797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56798       };
56799     } catch (std::exception& e) {
56800       {
56801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56802       };
56803     } catch (...) {
56804       {
56805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56806       };
56807     }
56808   }
56809   jresult = (int)result;
56810   return jresult;
56811 }
56812
56813
56814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56815   int jresult ;
56816   int result;
56817
56818   {
56819     try {
56820       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56821     } catch (std::out_of_range& e) {
56822       {
56823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56824       };
56825     } catch (std::exception& e) {
56826       {
56827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56828       };
56829     } catch (...) {
56830       {
56831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56832       };
56833     }
56834   }
56835   jresult = (int)result;
56836   return jresult;
56837 }
56838
56839
56840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56841   int jresult ;
56842   int result;
56843
56844   {
56845     try {
56846       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56847     } catch (std::out_of_range& e) {
56848       {
56849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56850       };
56851     } catch (std::exception& e) {
56852       {
56853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (...) {
56856       {
56857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56858       };
56859     }
56860   }
56861   jresult = (int)result;
56862   return jresult;
56863 }
56864
56865
56866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56867   int jresult ;
56868   int result;
56869
56870   {
56871     try {
56872       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56873     } catch (std::out_of_range& e) {
56874       {
56875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56876       };
56877     } catch (std::exception& e) {
56878       {
56879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56880       };
56881     } catch (...) {
56882       {
56883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56884       };
56885     }
56886   }
56887   jresult = (int)result;
56888   return jresult;
56889 }
56890
56891
56892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56893   int jresult ;
56894   int result;
56895
56896   {
56897     try {
56898       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56899     } catch (std::out_of_range& e) {
56900       {
56901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56902       };
56903     } catch (std::exception& e) {
56904       {
56905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56906       };
56907     } catch (...) {
56908       {
56909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56910       };
56911     }
56912   }
56913   jresult = (int)result;
56914   return jresult;
56915 }
56916
56917
56918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56919   int jresult ;
56920   int result;
56921
56922   {
56923     try {
56924       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56925     } catch (std::out_of_range& e) {
56926       {
56927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56928       };
56929     } catch (std::exception& e) {
56930       {
56931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56932       };
56933     } catch (...) {
56934       {
56935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56936       };
56937     }
56938   }
56939   jresult = (int)result;
56940   return jresult;
56941 }
56942
56943
56944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56945   int jresult ;
56946   int result;
56947
56948   {
56949     try {
56950       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56951     } catch (std::out_of_range& e) {
56952       {
56953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (std::exception& e) {
56956       {
56957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56962       };
56963     }
56964   }
56965   jresult = (int)result;
56966   return jresult;
56967 }
56968
56969
56970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56971   int jresult ;
56972   int result;
56973
56974   {
56975     try {
56976       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56977     } catch (std::out_of_range& e) {
56978       {
56979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56980       };
56981     } catch (std::exception& e) {
56982       {
56983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56984       };
56985     } catch (...) {
56986       {
56987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56988       };
56989     }
56990   }
56991   jresult = (int)result;
56992   return jresult;
56993 }
56994
56995
56996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56997   int jresult ;
56998   int result;
56999
57000   {
57001     try {
57002       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57003     } catch (std::out_of_range& e) {
57004       {
57005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57006       };
57007     } catch (std::exception& e) {
57008       {
57009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (...) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57014       };
57015     }
57016   }
57017   jresult = (int)result;
57018   return jresult;
57019 }
57020
57021
57022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57023   int jresult ;
57024   int result;
57025
57026   {
57027     try {
57028       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57029     } catch (std::out_of_range& e) {
57030       {
57031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57032       };
57033     } catch (std::exception& e) {
57034       {
57035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57036       };
57037     } catch (...) {
57038       {
57039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57040       };
57041     }
57042   }
57043   jresult = (int)result;
57044   return jresult;
57045 }
57046
57047
57048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57049   int jresult ;
57050   int result;
57051
57052   {
57053     try {
57054       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57055     } catch (std::out_of_range& e) {
57056       {
57057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57058       };
57059     } catch (std::exception& e) {
57060       {
57061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57062       };
57063     } catch (...) {
57064       {
57065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57066       };
57067     }
57068   }
57069   jresult = (int)result;
57070   return jresult;
57071 }
57072
57073
57074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57075   int jresult ;
57076   int result;
57077
57078   {
57079     try {
57080       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57081     } catch (std::out_of_range& e) {
57082       {
57083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57084       };
57085     } catch (std::exception& e) {
57086       {
57087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57088       };
57089     } catch (...) {
57090       {
57091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57092       };
57093     }
57094   }
57095   jresult = (int)result;
57096   return jresult;
57097 }
57098
57099
57100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57101   int jresult ;
57102   int result;
57103
57104   {
57105     try {
57106       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57107     } catch (std::out_of_range& e) {
57108       {
57109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57110       };
57111     } catch (std::exception& e) {
57112       {
57113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57114       };
57115     } catch (...) {
57116       {
57117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57118       };
57119     }
57120   }
57121   jresult = (int)result;
57122   return jresult;
57123 }
57124
57125
57126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57127   int jresult ;
57128   int result;
57129
57130   {
57131     try {
57132       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57133     } catch (std::out_of_range& e) {
57134       {
57135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57136       };
57137     } catch (std::exception& e) {
57138       {
57139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57140       };
57141     } catch (...) {
57142       {
57143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57144       };
57145     }
57146   }
57147   jresult = (int)result;
57148   return jresult;
57149 }
57150
57151
57152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57153   int jresult ;
57154   int result;
57155
57156   {
57157     try {
57158       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57159     } catch (std::out_of_range& e) {
57160       {
57161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57162       };
57163     } catch (std::exception& e) {
57164       {
57165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57166       };
57167     } catch (...) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57170       };
57171     }
57172   }
57173   jresult = (int)result;
57174   return jresult;
57175 }
57176
57177
57178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57179   int jresult ;
57180   int result;
57181
57182   {
57183     try {
57184       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57185     } catch (std::out_of_range& e) {
57186       {
57187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57188       };
57189     } catch (std::exception& e) {
57190       {
57191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57192       };
57193     } catch (...) {
57194       {
57195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57196       };
57197     }
57198   }
57199   jresult = (int)result;
57200   return jresult;
57201 }
57202
57203
57204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57205   int jresult ;
57206   int result;
57207
57208   {
57209     try {
57210       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57211     } catch (std::out_of_range& e) {
57212       {
57213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57214       };
57215     } catch (std::exception& e) {
57216       {
57217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57218       };
57219     } catch (...) {
57220       {
57221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57222       };
57223     }
57224   }
57225   jresult = (int)result;
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57231   int jresult ;
57232   int result;
57233
57234   {
57235     try {
57236       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57237     } catch (std::out_of_range& e) {
57238       {
57239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (std::exception& e) {
57242       {
57243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57244       };
57245     } catch (...) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57248       };
57249     }
57250   }
57251   jresult = (int)result;
57252   return jresult;
57253 }
57254
57255
57256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57257   int jresult ;
57258   int result;
57259
57260   {
57261     try {
57262       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57263     } catch (std::out_of_range& e) {
57264       {
57265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57266       };
57267     } catch (std::exception& e) {
57268       {
57269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57270       };
57271     } catch (...) {
57272       {
57273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57274       };
57275     }
57276   }
57277   jresult = (int)result;
57278   return jresult;
57279 }
57280
57281
57282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57283   int jresult ;
57284   int result;
57285
57286   {
57287     try {
57288       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57289     } catch (std::out_of_range& e) {
57290       {
57291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (std::exception& e) {
57294       {
57295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57300       };
57301     }
57302   }
57303   jresult = (int)result;
57304   return jresult;
57305 }
57306
57307
57308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57309   int jresult ;
57310   int result;
57311
57312   {
57313     try {
57314       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57315     } catch (std::out_of_range& e) {
57316       {
57317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (std::exception& e) {
57320       {
57321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57326       };
57327     }
57328   }
57329   jresult = (int)result;
57330   return jresult;
57331 }
57332
57333
57334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57335   int jresult ;
57336   int result;
57337
57338   {
57339     try {
57340       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57341     } catch (std::out_of_range& e) {
57342       {
57343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57344       };
57345     } catch (std::exception& e) {
57346       {
57347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57348       };
57349     } catch (...) {
57350       {
57351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57352       };
57353     }
57354   }
57355   jresult = (int)result;
57356   return jresult;
57357 }
57358
57359
57360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57361   int jresult ;
57362   int result;
57363
57364   {
57365     try {
57366       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57367     } catch (std::out_of_range& e) {
57368       {
57369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57370       };
57371     } catch (std::exception& e) {
57372       {
57373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57374       };
57375     } catch (...) {
57376       {
57377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57378       };
57379     }
57380   }
57381   jresult = (int)result;
57382   return jresult;
57383 }
57384
57385
57386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57387   int jresult ;
57388   int result;
57389
57390   {
57391     try {
57392       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57393     } catch (std::out_of_range& e) {
57394       {
57395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (std::exception& e) {
57398       {
57399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57404       };
57405     }
57406   }
57407   jresult = (int)result;
57408   return jresult;
57409 }
57410
57411
57412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57413   int jresult ;
57414   int result;
57415
57416   {
57417     try {
57418       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57419     } catch (std::out_of_range& e) {
57420       {
57421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57422       };
57423     } catch (std::exception& e) {
57424       {
57425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57426       };
57427     } catch (...) {
57428       {
57429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57430       };
57431     }
57432   }
57433   jresult = (int)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57439   int jresult ;
57440   int result;
57441
57442   {
57443     try {
57444       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57445     } catch (std::out_of_range& e) {
57446       {
57447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57448       };
57449     } catch (std::exception& e) {
57450       {
57451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57452       };
57453     } catch (...) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57456       };
57457     }
57458   }
57459   jresult = (int)result;
57460   return jresult;
57461 }
57462
57463
57464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57465   int jresult ;
57466   int result;
57467
57468   {
57469     try {
57470       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57471     } catch (std::out_of_range& e) {
57472       {
57473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57474       };
57475     } catch (std::exception& e) {
57476       {
57477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57478       };
57479     } catch (...) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57482       };
57483     }
57484   }
57485   jresult = (int)result;
57486   return jresult;
57487 }
57488
57489
57490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57491   int jresult ;
57492   int result;
57493
57494   {
57495     try {
57496       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57497     } catch (std::out_of_range& e) {
57498       {
57499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57500       };
57501     } catch (std::exception& e) {
57502       {
57503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57504       };
57505     } catch (...) {
57506       {
57507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57508       };
57509     }
57510   }
57511   jresult = (int)result;
57512   return jresult;
57513 }
57514
57515
57516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57517   int jresult ;
57518   int result;
57519
57520   {
57521     try {
57522       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57530       };
57531     } catch (...) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57534       };
57535     }
57536   }
57537   jresult = (int)result;
57538   return jresult;
57539 }
57540
57541
57542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57543   int jresult ;
57544   int result;
57545
57546   {
57547     try {
57548       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57549     } catch (std::out_of_range& e) {
57550       {
57551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57552       };
57553     } catch (std::exception& e) {
57554       {
57555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (...) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57560       };
57561     }
57562   }
57563   jresult = (int)result;
57564   return jresult;
57565 }
57566
57567
57568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57569   int jresult ;
57570   int result;
57571
57572   {
57573     try {
57574       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
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 (...) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57586       };
57587     }
57588   }
57589   jresult = (int)result;
57590   return jresult;
57591 }
57592
57593
57594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57595   int jresult ;
57596   int result;
57597
57598   {
57599     try {
57600       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57601     } catch (std::out_of_range& e) {
57602       {
57603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (std::exception& e) {
57606       {
57607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (...) {
57610       {
57611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57612       };
57613     }
57614   }
57615   jresult = (int)result;
57616   return jresult;
57617 }
57618
57619
57620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57621   int jresult ;
57622   int result;
57623
57624   {
57625     try {
57626       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57627     } catch (std::out_of_range& e) {
57628       {
57629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57630       };
57631     } catch (std::exception& e) {
57632       {
57633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57638       };
57639     }
57640   }
57641   jresult = (int)result;
57642   return jresult;
57643 }
57644
57645
57646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57647   int jresult ;
57648   int result;
57649
57650   {
57651     try {
57652       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57653     } catch (std::out_of_range& e) {
57654       {
57655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57656       };
57657     } catch (std::exception& e) {
57658       {
57659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57660       };
57661     } catch (...) {
57662       {
57663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57664       };
57665     }
57666   }
57667   jresult = (int)result;
57668   return jresult;
57669 }
57670
57671
57672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57673   int jresult ;
57674   int result;
57675
57676   {
57677     try {
57678       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57679     } catch (std::out_of_range& e) {
57680       {
57681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57682       };
57683     } catch (std::exception& e) {
57684       {
57685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57686       };
57687     } catch (...) {
57688       {
57689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57690       };
57691     }
57692   }
57693   jresult = (int)result;
57694   return jresult;
57695 }
57696
57697
57698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57699   int jresult ;
57700   int result;
57701
57702   {
57703     try {
57704       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57705     } catch (std::out_of_range& e) {
57706       {
57707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57708       };
57709     } catch (std::exception& e) {
57710       {
57711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57712       };
57713     } catch (...) {
57714       {
57715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57716       };
57717     }
57718   }
57719   jresult = (int)result;
57720   return jresult;
57721 }
57722
57723
57724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57725   int jresult ;
57726   int result;
57727
57728   {
57729     try {
57730       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57731     } catch (std::out_of_range& e) {
57732       {
57733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (std::exception& e) {
57736       {
57737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57738       };
57739     } catch (...) {
57740       {
57741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57742       };
57743     }
57744   }
57745   jresult = (int)result;
57746   return jresult;
57747 }
57748
57749
57750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57751   int jresult ;
57752   int result;
57753
57754   {
57755     try {
57756       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57757     } catch (std::out_of_range& e) {
57758       {
57759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (std::exception& e) {
57762       {
57763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (...) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57768       };
57769     }
57770   }
57771   jresult = (int)result;
57772   return jresult;
57773 }
57774
57775
57776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57777   int jresult ;
57778   int result;
57779
57780   {
57781     try {
57782       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (...) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57794       };
57795     }
57796   }
57797   jresult = (int)result;
57798   return jresult;
57799 }
57800
57801
57802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57803   int jresult ;
57804   int result;
57805
57806   {
57807     try {
57808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57809     } catch (std::out_of_range& e) {
57810       {
57811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57812       };
57813     } catch (std::exception& e) {
57814       {
57815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57820       };
57821     }
57822   }
57823   jresult = (int)result;
57824   return jresult;
57825 }
57826
57827
57828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57829   int jresult ;
57830   int result;
57831
57832   {
57833     try {
57834       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (...) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57846       };
57847     }
57848   }
57849   jresult = (int)result;
57850   return jresult;
57851 }
57852
57853
57854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57855   int jresult ;
57856   int result;
57857
57858   {
57859     try {
57860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57861     } catch (std::out_of_range& e) {
57862       {
57863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57864       };
57865     } catch (std::exception& e) {
57866       {
57867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57868       };
57869     } catch (...) {
57870       {
57871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57872       };
57873     }
57874   }
57875   jresult = (int)result;
57876   return jresult;
57877 }
57878
57879
57880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57881   int jresult ;
57882   int result;
57883
57884   {
57885     try {
57886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57887     } catch (std::out_of_range& e) {
57888       {
57889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57890       };
57891     } catch (std::exception& e) {
57892       {
57893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57894       };
57895     } catch (...) {
57896       {
57897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57898       };
57899     }
57900   }
57901   jresult = (int)result;
57902   return jresult;
57903 }
57904
57905
57906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57907   int jresult ;
57908   int result;
57909
57910   {
57911     try {
57912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927   jresult = (int)result;
57928   return jresult;
57929 }
57930
57931
57932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57933   int jresult ;
57934   int result;
57935
57936   {
57937     try {
57938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57946       };
57947     } catch (...) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57950       };
57951     }
57952   }
57953   jresult = (int)result;
57954   return jresult;
57955 }
57956
57957
57958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57959   int jresult ;
57960   int result;
57961
57962   {
57963     try {
57964       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57965     } catch (std::out_of_range& e) {
57966       {
57967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57968       };
57969     } catch (std::exception& e) {
57970       {
57971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57972       };
57973     } catch (...) {
57974       {
57975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57976       };
57977     }
57978   }
57979   jresult = (int)result;
57980   return jresult;
57981 }
57982
57983
57984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57985   int jresult ;
57986   int result;
57987
57988   {
57989     try {
57990       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
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 (...) {
58000       {
58001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58002       };
58003     }
58004   }
58005   jresult = (int)result;
58006   return jresult;
58007 }
58008
58009
58010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58011   int jresult ;
58012   int result;
58013
58014   {
58015     try {
58016       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58017     } catch (std::out_of_range& e) {
58018       {
58019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58020       };
58021     } catch (std::exception& e) {
58022       {
58023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58024       };
58025     } catch (...) {
58026       {
58027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58028       };
58029     }
58030   }
58031   jresult = (int)result;
58032   return jresult;
58033 }
58034
58035
58036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58037   int jresult ;
58038   int result;
58039
58040   {
58041     try {
58042       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58050       };
58051     } catch (...) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58054       };
58055     }
58056   }
58057   jresult = (int)result;
58058   return jresult;
58059 }
58060
58061
58062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58063   int jresult ;
58064   int result;
58065
58066   {
58067     try {
58068       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58069     } catch (std::out_of_range& e) {
58070       {
58071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58072       };
58073     } catch (std::exception& e) {
58074       {
58075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58076       };
58077     } catch (...) {
58078       {
58079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58080       };
58081     }
58082   }
58083   jresult = (int)result;
58084   return jresult;
58085 }
58086
58087
58088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58089   int jresult ;
58090   int result;
58091
58092   {
58093     try {
58094       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58095     } catch (std::out_of_range& e) {
58096       {
58097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (std::exception& e) {
58100       {
58101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58102       };
58103     } catch (...) {
58104       {
58105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58106       };
58107     }
58108   }
58109   jresult = (int)result;
58110   return jresult;
58111 }
58112
58113
58114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58115   int jresult ;
58116   int result;
58117
58118   {
58119     try {
58120       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58121     } catch (std::out_of_range& e) {
58122       {
58123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58124       };
58125     } catch (std::exception& e) {
58126       {
58127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58128       };
58129     } catch (...) {
58130       {
58131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58132       };
58133     }
58134   }
58135   jresult = (int)result;
58136   return jresult;
58137 }
58138
58139
58140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58141   int jresult ;
58142   int result;
58143
58144   {
58145     try {
58146       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58147     } catch (std::out_of_range& e) {
58148       {
58149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58150       };
58151     } catch (std::exception& e) {
58152       {
58153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58154       };
58155     } catch (...) {
58156       {
58157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58158       };
58159     }
58160   }
58161   jresult = (int)result;
58162   return jresult;
58163 }
58164
58165
58166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58167   int jresult ;
58168   int result;
58169
58170   {
58171     try {
58172       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58173     } catch (std::out_of_range& e) {
58174       {
58175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58176       };
58177     } catch (std::exception& e) {
58178       {
58179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58180       };
58181     } catch (...) {
58182       {
58183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58184       };
58185     }
58186   }
58187   jresult = (int)result;
58188   return jresult;
58189 }
58190
58191
58192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58193   int jresult ;
58194   int result;
58195
58196   {
58197     try {
58198       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58199     } catch (std::out_of_range& e) {
58200       {
58201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58202       };
58203     } catch (std::exception& e) {
58204       {
58205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58206       };
58207     } catch (...) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58210       };
58211     }
58212   }
58213   jresult = (int)result;
58214   return jresult;
58215 }
58216
58217
58218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58219   int jresult ;
58220   int result;
58221
58222   {
58223     try {
58224       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (...) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58236       };
58237     }
58238   }
58239   jresult = (int)result;
58240   return jresult;
58241 }
58242
58243
58244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58245   int jresult ;
58246   int result;
58247
58248   {
58249     try {
58250       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58251     } catch (std::out_of_range& e) {
58252       {
58253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58254       };
58255     } catch (std::exception& e) {
58256       {
58257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (...) {
58260       {
58261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58262       };
58263     }
58264   }
58265   jresult = (int)result;
58266   return jresult;
58267 }
58268
58269
58270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58271   void * jresult ;
58272   Dali::Toolkit::Builder *result = 0 ;
58273
58274   {
58275     try {
58276       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58277     } catch (std::out_of_range& e) {
58278       {
58279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58280       };
58281     } catch (std::exception& e) {
58282       {
58283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58284       };
58285     } catch (...) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58288       };
58289     }
58290   }
58291   jresult = (void *)result;
58292   return jresult;
58293 }
58294
58295
58296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58297   void * jresult ;
58298   Dali::Toolkit::Builder result;
58299
58300   {
58301     try {
58302       result = Dali::Toolkit::Builder::New();
58303     } catch (std::out_of_range& e) {
58304       {
58305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (std::exception& e) {
58308       {
58309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (...) {
58312       {
58313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58314       };
58315     }
58316   }
58317   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58318   return jresult;
58319 }
58320
58321
58322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58324
58325   arg1 = (Dali::Toolkit::Builder *)jarg1;
58326   {
58327     try {
58328       delete arg1;
58329     } catch (std::out_of_range& e) {
58330       {
58331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58332       };
58333     } catch (std::exception& e) {
58334       {
58335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58340       };
58341     }
58342   }
58343 }
58344
58345
58346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58347   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58348   std::string *arg2 = 0 ;
58349   Dali::Toolkit::Builder::UIFormat arg3 ;
58350
58351   arg1 = (Dali::Toolkit::Builder *)jarg1;
58352   if (!jarg2) {
58353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58354     return ;
58355   }
58356   std::string arg2_str(jarg2);
58357   arg2 = &arg2_str;
58358   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58359   {
58360     try {
58361       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58362     } catch (std::out_of_range& e) {
58363       {
58364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58365       };
58366     } catch (std::exception& e) {
58367       {
58368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58369       };
58370     } catch (...) {
58371       {
58372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58373       };
58374     }
58375   }
58376
58377   //argout typemap for const std::string&
58378
58379 }
58380
58381
58382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58383   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58384   std::string *arg2 = 0 ;
58385
58386   arg1 = (Dali::Toolkit::Builder *)jarg1;
58387   if (!jarg2) {
58388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58389     return ;
58390   }
58391   std::string arg2_str(jarg2);
58392   arg2 = &arg2_str;
58393   {
58394     try {
58395       (arg1)->LoadFromString((std::string const &)*arg2);
58396     } catch (std::out_of_range& e) {
58397       {
58398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58399       };
58400     } catch (std::exception& e) {
58401       {
58402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58403       };
58404     } catch (...) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58407       };
58408     }
58409   }
58410
58411   //argout typemap for const std::string&
58412
58413 }
58414
58415
58416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58418   Dali::Property::Map *arg2 = 0 ;
58419
58420   arg1 = (Dali::Toolkit::Builder *)jarg1;
58421   arg2 = (Dali::Property::Map *)jarg2;
58422   if (!arg2) {
58423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58424     return ;
58425   }
58426   {
58427     try {
58428       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58429     } catch (std::out_of_range& e) {
58430       {
58431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58432       };
58433     } catch (std::exception& e) {
58434       {
58435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58436       };
58437     } catch (...) {
58438       {
58439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58440       };
58441     }
58442   }
58443 }
58444
58445
58446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58447   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58448   std::string *arg2 = 0 ;
58449   Dali::Property::Value *arg3 = 0 ;
58450
58451   arg1 = (Dali::Toolkit::Builder *)jarg1;
58452   if (!jarg2) {
58453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58454     return ;
58455   }
58456   std::string arg2_str(jarg2);
58457   arg2 = &arg2_str;
58458   arg3 = (Dali::Property::Value *)jarg3;
58459   if (!arg3) {
58460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58461     return ;
58462   }
58463   {
58464     try {
58465       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58466     } catch (std::out_of_range& e) {
58467       {
58468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58469       };
58470     } catch (std::exception& e) {
58471       {
58472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58473       };
58474     } catch (...) {
58475       {
58476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58477       };
58478     }
58479   }
58480
58481   //argout typemap for const std::string&
58482
58483 }
58484
58485
58486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58487   void * jresult ;
58488   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58489   Dali::Property::Map *result = 0 ;
58490
58491   arg1 = (Dali::Toolkit::Builder *)jarg1;
58492   {
58493     try {
58494       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58495     } catch (std::out_of_range& e) {
58496       {
58497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58498       };
58499     } catch (std::exception& e) {
58500       {
58501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58502       };
58503     } catch (...) {
58504       {
58505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58506       };
58507     }
58508   }
58509   jresult = (void *)result;
58510   return jresult;
58511 }
58512
58513
58514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58515   void * jresult ;
58516   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58517   std::string *arg2 = 0 ;
58518   Dali::Property::Value *result = 0 ;
58519
58520   arg1 = (Dali::Toolkit::Builder *)jarg1;
58521   if (!jarg2) {
58522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58523     return 0;
58524   }
58525   std::string arg2_str(jarg2);
58526   arg2 = &arg2_str;
58527   {
58528     try {
58529       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58530     } catch (std::out_of_range& e) {
58531       {
58532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58533       };
58534     } catch (std::exception& e) {
58535       {
58536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58537       };
58538     } catch (...) {
58539       {
58540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58541       };
58542     }
58543   }
58544   jresult = (void *)result;
58545
58546   //argout typemap for const std::string&
58547
58548   return jresult;
58549 }
58550
58551
58552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58553   void * jresult ;
58554   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58555   std::string *arg2 = 0 ;
58556   Dali::Animation result;
58557
58558   arg1 = (Dali::Toolkit::Builder *)jarg1;
58559   if (!jarg2) {
58560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58561     return 0;
58562   }
58563   std::string arg2_str(jarg2);
58564   arg2 = &arg2_str;
58565   {
58566     try {
58567       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58575       };
58576     } catch (...) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58579       };
58580     }
58581   }
58582   jresult = new Dali::Animation((const Dali::Animation &)result);
58583
58584   //argout typemap for const std::string&
58585
58586   return jresult;
58587 }
58588
58589
58590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58591   void * jresult ;
58592   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58593   std::string *arg2 = 0 ;
58594   Dali::Property::Map *arg3 = 0 ;
58595   Dali::Animation result;
58596
58597   arg1 = (Dali::Toolkit::Builder *)jarg1;
58598   if (!jarg2) {
58599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58600     return 0;
58601   }
58602   std::string arg2_str(jarg2);
58603   arg2 = &arg2_str;
58604   arg3 = (Dali::Property::Map *)jarg3;
58605   if (!arg3) {
58606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58607     return 0;
58608   }
58609   {
58610     try {
58611       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58612     } catch (std::out_of_range& e) {
58613       {
58614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58615       };
58616     } catch (std::exception& e) {
58617       {
58618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58619       };
58620     } catch (...) {
58621       {
58622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58623       };
58624     }
58625   }
58626   jresult = new Dali::Animation((const Dali::Animation &)result);
58627
58628   //argout typemap for const std::string&
58629
58630   return jresult;
58631 }
58632
58633
58634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58635   void * jresult ;
58636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58637   std::string *arg2 = 0 ;
58638   Dali::Actor arg3 ;
58639   Dali::Actor *argp3 ;
58640   Dali::Animation result;
58641
58642   arg1 = (Dali::Toolkit::Builder *)jarg1;
58643   if (!jarg2) {
58644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58645     return 0;
58646   }
58647   std::string arg2_str(jarg2);
58648   arg2 = &arg2_str;
58649   argp3 = (Dali::Actor *)jarg3;
58650   if (!argp3) {
58651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58652     return 0;
58653   }
58654   arg3 = *argp3;
58655   {
58656     try {
58657       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58658     } catch (std::out_of_range& e) {
58659       {
58660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58661       };
58662     } catch (std::exception& e) {
58663       {
58664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58669       };
58670     }
58671   }
58672   jresult = new Dali::Animation((const Dali::Animation &)result);
58673
58674   //argout typemap for const std::string&
58675
58676   return jresult;
58677 }
58678
58679
58680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58681   void * jresult ;
58682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58683   std::string *arg2 = 0 ;
58684   Dali::Property::Map *arg3 = 0 ;
58685   Dali::Actor arg4 ;
58686   Dali::Actor *argp4 ;
58687   Dali::Animation result;
58688
58689   arg1 = (Dali::Toolkit::Builder *)jarg1;
58690   if (!jarg2) {
58691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58692     return 0;
58693   }
58694   std::string arg2_str(jarg2);
58695   arg2 = &arg2_str;
58696   arg3 = (Dali::Property::Map *)jarg3;
58697   if (!arg3) {
58698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58699     return 0;
58700   }
58701   argp4 = (Dali::Actor *)jarg4;
58702   if (!argp4) {
58703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58704     return 0;
58705   }
58706   arg4 = *argp4;
58707   {
58708     try {
58709       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58710     } catch (std::out_of_range& e) {
58711       {
58712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58713       };
58714     } catch (std::exception& e) {
58715       {
58716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58717       };
58718     } catch (...) {
58719       {
58720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58721       };
58722     }
58723   }
58724   jresult = new Dali::Animation((const Dali::Animation &)result);
58725
58726   //argout typemap for const std::string&
58727
58728   return jresult;
58729 }
58730
58731
58732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58733   void * jresult ;
58734   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58735   std::string *arg2 = 0 ;
58736   Dali::BaseHandle result;
58737
58738   arg1 = (Dali::Toolkit::Builder *)jarg1;
58739   if (!jarg2) {
58740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58741     return 0;
58742   }
58743   std::string arg2_str(jarg2);
58744   arg2 = &arg2_str;
58745   {
58746     try {
58747       result = (arg1)->Create((std::string const &)*arg2);
58748     } catch (std::out_of_range& e) {
58749       {
58750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58751       };
58752     } catch (std::exception& e) {
58753       {
58754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58755       };
58756     } catch (...) {
58757       {
58758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58759       };
58760     }
58761   }
58762   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58763
58764   //argout typemap for const std::string&
58765
58766   return jresult;
58767 }
58768
58769
58770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58771   void * jresult ;
58772   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58773   std::string *arg2 = 0 ;
58774   Dali::Property::Map *arg3 = 0 ;
58775   Dali::BaseHandle result;
58776
58777   arg1 = (Dali::Toolkit::Builder *)jarg1;
58778   if (!jarg2) {
58779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58780     return 0;
58781   }
58782   std::string arg2_str(jarg2);
58783   arg2 = &arg2_str;
58784   arg3 = (Dali::Property::Map *)jarg3;
58785   if (!arg3) {
58786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58787     return 0;
58788   }
58789   {
58790     try {
58791       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58792     } catch (std::out_of_range& e) {
58793       {
58794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58795       };
58796     } catch (std::exception& e) {
58797       {
58798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58799       };
58800     } catch (...) {
58801       {
58802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58803       };
58804     }
58805   }
58806   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58807
58808   //argout typemap for const std::string&
58809
58810   return jresult;
58811 }
58812
58813
58814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58815   void * jresult ;
58816   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58817   std::string *arg2 = 0 ;
58818   Dali::BaseHandle result;
58819
58820   arg1 = (Dali::Toolkit::Builder *)jarg1;
58821   if (!jarg2) {
58822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58823     return 0;
58824   }
58825   std::string arg2_str(jarg2);
58826   arg2 = &arg2_str;
58827   {
58828     try {
58829       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58830     } catch (std::out_of_range& e) {
58831       {
58832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58833       };
58834     } catch (std::exception& e) {
58835       {
58836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58837       };
58838     } catch (...) {
58839       {
58840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58841       };
58842     }
58843   }
58844   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58845
58846   //argout typemap for const std::string&
58847
58848   return jresult;
58849 }
58850
58851
58852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58853   unsigned int jresult ;
58854   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58855   std::string *arg2 = 0 ;
58856   Dali::Handle *arg3 = 0 ;
58857   bool result;
58858
58859   arg1 = (Dali::Toolkit::Builder *)jarg1;
58860   if (!jarg2) {
58861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58862     return 0;
58863   }
58864   std::string arg2_str(jarg2);
58865   arg2 = &arg2_str;
58866   arg3 = (Dali::Handle *)jarg3;
58867   if (!arg3) {
58868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58869     return 0;
58870   }
58871   {
58872     try {
58873       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58874     } catch (std::out_of_range& e) {
58875       {
58876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58877       };
58878     } catch (std::exception& e) {
58879       {
58880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58881       };
58882     } catch (...) {
58883       {
58884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58885       };
58886     }
58887   }
58888   jresult = result;
58889
58890   //argout typemap for const std::string&
58891
58892   return jresult;
58893 }
58894
58895
58896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58897   unsigned int jresult ;
58898   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58899   Dali::Handle *arg2 = 0 ;
58900   std::string *arg3 = 0 ;
58901   bool result;
58902
58903   arg1 = (Dali::Toolkit::Builder *)jarg1;
58904   arg2 = (Dali::Handle *)jarg2;
58905   if (!arg2) {
58906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58907     return 0;
58908   }
58909   if (!jarg3) {
58910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58911     return 0;
58912   }
58913   std::string arg3_str(jarg3);
58914   arg3 = &arg3_str;
58915   {
58916     try {
58917       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58918     } catch (std::out_of_range& e) {
58919       {
58920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58921       };
58922     } catch (std::exception& e) {
58923       {
58924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (...) {
58927       {
58928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58929       };
58930     }
58931   }
58932   jresult = result;
58933
58934   //argout typemap for const std::string&
58935
58936   return jresult;
58937 }
58938
58939
58940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58942   Dali::Actor arg2 ;
58943   Dali::Actor *argp2 ;
58944
58945   arg1 = (Dali::Toolkit::Builder *)jarg1;
58946   argp2 = (Dali::Actor *)jarg2;
58947   if (!argp2) {
58948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58949     return ;
58950   }
58951   arg2 = *argp2;
58952   {
58953     try {
58954       (arg1)->AddActors(arg2);
58955     } catch (std::out_of_range& e) {
58956       {
58957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58958       };
58959     } catch (std::exception& e) {
58960       {
58961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58962       };
58963     } catch (...) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58966       };
58967     }
58968   }
58969 }
58970
58971
58972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58973   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58974   std::string *arg2 = 0 ;
58975   Dali::Actor arg3 ;
58976   Dali::Actor *argp3 ;
58977
58978   arg1 = (Dali::Toolkit::Builder *)jarg1;
58979   if (!jarg2) {
58980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58981     return ;
58982   }
58983   std::string arg2_str(jarg2);
58984   arg2 = &arg2_str;
58985   argp3 = (Dali::Actor *)jarg3;
58986   if (!argp3) {
58987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58988     return ;
58989   }
58990   arg3 = *argp3;
58991   {
58992     try {
58993       (arg1)->AddActors((std::string const &)*arg2,arg3);
58994     } catch (std::out_of_range& e) {
58995       {
58996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58997       };
58998     } catch (std::exception& e) {
58999       {
59000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59001       };
59002     } catch (...) {
59003       {
59004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59005       };
59006     }
59007   }
59008
59009   //argout typemap for const std::string&
59010
59011 }
59012
59013
59014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59015   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59016   std::string *arg2 = 0 ;
59017
59018   arg1 = (Dali::Toolkit::Builder *)jarg1;
59019   if (!jarg2) {
59020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59021     return ;
59022   }
59023   std::string arg2_str(jarg2);
59024   arg2 = &arg2_str;
59025   {
59026     try {
59027       (arg1)->CreateRenderTask((std::string const &)*arg2);
59028     } catch (std::out_of_range& e) {
59029       {
59030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59031       };
59032     } catch (std::exception& e) {
59033       {
59034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59035       };
59036     } catch (...) {
59037       {
59038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59039       };
59040     }
59041   }
59042
59043   //argout typemap for const std::string&
59044
59045 }
59046
59047
59048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59049   void * jresult ;
59050   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59051   std::string *arg2 = 0 ;
59052   Dali::FrameBufferImage result;
59053
59054   arg1 = (Dali::Toolkit::Builder *)jarg1;
59055   if (!jarg2) {
59056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59057     return 0;
59058   }
59059   std::string arg2_str(jarg2);
59060   arg2 = &arg2_str;
59061   {
59062     try {
59063       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59064     } catch (std::out_of_range& e) {
59065       {
59066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59067       };
59068     } catch (std::exception& e) {
59069       {
59070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59071       };
59072     } catch (...) {
59073       {
59074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59075       };
59076     }
59077   }
59078   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59079
59080   //argout typemap for const std::string&
59081
59082   return jresult;
59083 }
59084
59085
59086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59087   void * jresult ;
59088   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59089   std::string *arg2 = 0 ;
59090   Dali::Path result;
59091
59092   arg1 = (Dali::Toolkit::Builder *)jarg1;
59093   if (!jarg2) {
59094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59095     return 0;
59096   }
59097   std::string arg2_str(jarg2);
59098   arg2 = &arg2_str;
59099   {
59100     try {
59101       result = (arg1)->GetPath((std::string const &)*arg2);
59102     } catch (std::out_of_range& e) {
59103       {
59104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59105       };
59106     } catch (std::exception& e) {
59107       {
59108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59109       };
59110     } catch (...) {
59111       {
59112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59113       };
59114     }
59115   }
59116   jresult = new Dali::Path((const Dali::Path &)result);
59117
59118   //argout typemap for const std::string&
59119
59120   return jresult;
59121 }
59122
59123
59124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59125   void * jresult ;
59126   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59127   std::string *arg2 = 0 ;
59128   Dali::PathConstrainer result;
59129
59130   arg1 = (Dali::Toolkit::Builder *)jarg1;
59131   if (!jarg2) {
59132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59133     return 0;
59134   }
59135   std::string arg2_str(jarg2);
59136   arg2 = &arg2_str;
59137   {
59138     try {
59139       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59140     } catch (std::out_of_range& e) {
59141       {
59142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59143       };
59144     } catch (std::exception& e) {
59145       {
59146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59147       };
59148     } catch (...) {
59149       {
59150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59151       };
59152     }
59153   }
59154   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59155
59156   //argout typemap for const std::string&
59157
59158   return jresult;
59159 }
59160
59161
59162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59163   void * jresult ;
59164   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59165   std::string *arg2 = 0 ;
59166   Dali::LinearConstrainer result;
59167
59168   arg1 = (Dali::Toolkit::Builder *)jarg1;
59169   if (!jarg2) {
59170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59171     return 0;
59172   }
59173   std::string arg2_str(jarg2);
59174   arg2 = &arg2_str;
59175   {
59176     try {
59177       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59178     } catch (std::out_of_range& e) {
59179       {
59180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59181       };
59182     } catch (std::exception& e) {
59183       {
59184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59185       };
59186     } catch (...) {
59187       {
59188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59189       };
59190     }
59191   }
59192   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59193
59194   //argout typemap for const std::string&
59195
59196   return jresult;
59197 }
59198
59199
59200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59201   void * jresult ;
59202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59203   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59204
59205   arg1 = (Dali::Toolkit::Builder *)jarg1;
59206   {
59207     try {
59208       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59209     } catch (std::out_of_range& e) {
59210       {
59211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59212       };
59213     } catch (std::exception& e) {
59214       {
59215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59216       };
59217     } catch (...) {
59218       {
59219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59220       };
59221     }
59222   }
59223   jresult = (void *)result;
59224   return jresult;
59225 }
59226
59227
59228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59229   void * jresult ;
59230   Dali::Toolkit::TransitionData *result = 0 ;
59231
59232   {
59233     try {
59234       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59235     } catch (std::out_of_range& e) {
59236       {
59237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (std::exception& e) {
59240       {
59241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (...) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59246       };
59247     }
59248   }
59249   jresult = (void *)result;
59250   return jresult;
59251 }
59252
59253
59254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59255   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59256
59257   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59258   {
59259     try {
59260       delete arg1;
59261     } catch (std::out_of_range& e) {
59262       {
59263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59264       };
59265     } catch (std::exception& e) {
59266       {
59267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59268       };
59269     } catch (...) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59272       };
59273     }
59274   }
59275 }
59276
59277
59278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59279   void * jresult ;
59280   Dali::Property::Map *arg1 = 0 ;
59281   Dali::Toolkit::TransitionData result;
59282
59283   arg1 = (Dali::Property::Map *)jarg1;
59284   if (!arg1) {
59285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59286     return 0;
59287   }
59288   {
59289     try {
59290       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59291     } catch (std::out_of_range& e) {
59292       {
59293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59294       };
59295     } catch (std::exception& e) {
59296       {
59297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59298       };
59299     } catch (...) {
59300       {
59301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59302       };
59303     }
59304   }
59305   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59306   return jresult;
59307 }
59308
59309
59310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59311   void * jresult ;
59312   Dali::Property::Array *arg1 = 0 ;
59313   Dali::Toolkit::TransitionData result;
59314
59315   arg1 = (Dali::Property::Array *)jarg1;
59316   if (!arg1) {
59317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59318     return 0;
59319   }
59320   {
59321     try {
59322       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59323     } catch (std::out_of_range& e) {
59324       {
59325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (std::exception& e) {
59328       {
59329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59330       };
59331     } catch (...) {
59332       {
59333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59334       };
59335     }
59336   }
59337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59338   return jresult;
59339 }
59340
59341
59342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59343   void * jresult ;
59344   Dali::BaseHandle arg1 ;
59345   Dali::BaseHandle *argp1 ;
59346   Dali::Toolkit::TransitionData result;
59347
59348   argp1 = (Dali::BaseHandle *)jarg1;
59349   if (!argp1) {
59350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59351     return 0;
59352   }
59353   arg1 = *argp1;
59354   {
59355     try {
59356       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59357     } catch (std::out_of_range& e) {
59358       {
59359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59360       };
59361     } catch (std::exception& e) {
59362       {
59363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59364       };
59365     } catch (...) {
59366       {
59367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59368       };
59369     }
59370   }
59371   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59372   return jresult;
59373 }
59374
59375
59376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59377   void * jresult ;
59378   Dali::Toolkit::TransitionData *arg1 = 0 ;
59379   Dali::Toolkit::TransitionData *result = 0 ;
59380
59381   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59382   if (!arg1) {
59383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59384     return 0;
59385   }
59386   {
59387     try {
59388       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59389     } catch (std::out_of_range& e) {
59390       {
59391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59392       };
59393     } catch (std::exception& e) {
59394       {
59395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59396       };
59397     } catch (...) {
59398       {
59399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59400       };
59401     }
59402   }
59403   jresult = (void *)result;
59404   return jresult;
59405 }
59406
59407
59408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59409   void * jresult ;
59410   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59411   Dali::Toolkit::TransitionData *arg2 = 0 ;
59412   Dali::Toolkit::TransitionData *result = 0 ;
59413
59414   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59415   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59416   if (!arg2) {
59417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59418     return 0;
59419   }
59420   {
59421     try {
59422       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59423     } catch (std::out_of_range& e) {
59424       {
59425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59426       };
59427     } catch (std::exception& e) {
59428       {
59429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59430       };
59431     } catch (...) {
59432       {
59433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59434       };
59435     }
59436   }
59437   jresult = (void *)result;
59438   return jresult;
59439 }
59440
59441
59442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59443   unsigned long jresult ;
59444   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59445   size_t result;
59446
59447   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59448   {
59449     try {
59450       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59451     } catch (std::out_of_range& e) {
59452       {
59453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59454       };
59455     } catch (std::exception& e) {
59456       {
59457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (...) {
59460       {
59461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59462       };
59463     }
59464   }
59465   jresult = (unsigned long)result;
59466   return jresult;
59467 }
59468
59469
59470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59471   void * jresult ;
59472   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59473   size_t arg2 ;
59474   Dali::Property::Map result;
59475
59476   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59477   arg2 = (size_t)jarg2;
59478   {
59479     try {
59480       result = (arg1)->GetAnimatorAt(arg2);
59481     } catch (std::out_of_range& e) {
59482       {
59483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (std::exception& e) {
59486       {
59487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59492       };
59493     }
59494   }
59495   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59501   void * jresult ;
59502   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59503   Dali::Toolkit::TransitionData *result = 0 ;
59504
59505   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59506   {
59507     try {
59508       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59509     } catch (std::out_of_range& e) {
59510       {
59511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59512       };
59513     } catch (std::exception& e) {
59514       {
59515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59516       };
59517     } catch (...) {
59518       {
59519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59520       };
59521     }
59522   }
59523   jresult = (void *)result;
59524   return jresult;
59525 }
59526
59527
59528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59529   int jresult ;
59530   int result;
59531
59532   {
59533     try {
59534       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59535     } catch (std::out_of_range& e) {
59536       {
59537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (std::exception& e) {
59540       {
59541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59542       };
59543     } catch (...) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59546       };
59547     }
59548   }
59549   jresult = (int)result;
59550   return jresult;
59551 }
59552
59553
59554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59555   int jresult ;
59556   int result;
59557
59558   {
59559     try {
59560       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59561     } catch (std::out_of_range& e) {
59562       {
59563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (std::exception& e) {
59566       {
59567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (...) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59572       };
59573     }
59574   }
59575   jresult = (int)result;
59576   return jresult;
59577 }
59578
59579
59580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59581   int jresult ;
59582   int result;
59583
59584   {
59585     try {
59586       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59587     } catch (std::out_of_range& e) {
59588       {
59589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (std::exception& e) {
59592       {
59593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (...) {
59596       {
59597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59598       };
59599     }
59600   }
59601   jresult = (int)result;
59602   return jresult;
59603 }
59604
59605
59606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59607   int jresult ;
59608   int result;
59609
59610   {
59611     try {
59612       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59613     } catch (std::out_of_range& e) {
59614       {
59615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59616       };
59617     } catch (std::exception& e) {
59618       {
59619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59620       };
59621     } catch (...) {
59622       {
59623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59624       };
59625     }
59626   }
59627   jresult = (int)result;
59628   return jresult;
59629 }
59630
59631
59632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59633   int jresult ;
59634   int result;
59635
59636   {
59637     try {
59638       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59639     } catch (std::out_of_range& e) {
59640       {
59641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59642       };
59643     } catch (std::exception& e) {
59644       {
59645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (...) {
59648       {
59649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59650       };
59651     }
59652   }
59653   jresult = (int)result;
59654   return jresult;
59655 }
59656
59657
59658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59659   int jresult ;
59660   int result;
59661
59662   {
59663     try {
59664       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59665     } catch (std::out_of_range& e) {
59666       {
59667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (std::exception& e) {
59670       {
59671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59676       };
59677     }
59678   }
59679   jresult = (int)result;
59680   return jresult;
59681 }
59682
59683
59684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59685   int jresult ;
59686   int result;
59687
59688   {
59689     try {
59690       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705   jresult = (int)result;
59706   return jresult;
59707 }
59708
59709
59710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59711   int jresult ;
59712   int result;
59713
59714   {
59715     try {
59716       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59717     } catch (std::out_of_range& e) {
59718       {
59719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (std::exception& e) {
59722       {
59723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (...) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59728       };
59729     }
59730   }
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59737   int jresult ;
59738   int result;
59739
59740   {
59741     try {
59742       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (...) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59754       };
59755     }
59756   }
59757   jresult = (int)result;
59758   return jresult;
59759 }
59760
59761
59762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59763   int jresult ;
59764   int result;
59765
59766   {
59767     try {
59768       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59769     } catch (std::out_of_range& e) {
59770       {
59771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59772       };
59773     } catch (std::exception& e) {
59774       {
59775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (...) {
59778       {
59779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59780       };
59781     }
59782   }
59783   jresult = (int)result;
59784   return jresult;
59785 }
59786
59787
59788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59789   int jresult ;
59790   int result;
59791
59792   {
59793     try {
59794       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59795     } catch (std::out_of_range& e) {
59796       {
59797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59798       };
59799     } catch (std::exception& e) {
59800       {
59801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59802       };
59803     } catch (...) {
59804       {
59805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59806       };
59807     }
59808   }
59809   jresult = (int)result;
59810   return jresult;
59811 }
59812
59813
59814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59815   int jresult ;
59816   int result;
59817
59818   {
59819     try {
59820       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59821     } catch (std::out_of_range& e) {
59822       {
59823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (std::exception& e) {
59826       {
59827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (...) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59832       };
59833     }
59834   }
59835   jresult = (int)result;
59836   return jresult;
59837 }
59838
59839
59840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59841   int jresult ;
59842   int result;
59843
59844   {
59845     try {
59846       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59847     } catch (std::out_of_range& e) {
59848       {
59849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (std::exception& e) {
59852       {
59853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (...) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59858       };
59859     }
59860   }
59861   jresult = (int)result;
59862   return jresult;
59863 }
59864
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (...) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59884       };
59885     }
59886   }
59887   jresult = (int)result;
59888   return jresult;
59889 }
59890
59891
59892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59893   void * jresult ;
59894   Dali::Toolkit::Control result;
59895
59896   {
59897     try {
59898       result = Dali::Toolkit::Internal::Control::New();
59899     } catch (std::out_of_range& e) {
59900       {
59901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59902       };
59903     } catch (std::exception& e) {
59904       {
59905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59906       };
59907     } catch (...) {
59908       {
59909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59910       };
59911     }
59912   }
59913   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59914   return jresult;
59915 }
59916
59917
59918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59920   std::string *arg2 = 0 ;
59921
59922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59923   if (!jarg2) {
59924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59925     return ;
59926   }
59927   std::string arg2_str(jarg2);
59928   arg2 = &arg2_str;
59929   {
59930     try {
59931       (arg1)->SetStyleName((std::string const &)*arg2);
59932     } catch (std::out_of_range& e) {
59933       {
59934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59935       };
59936     } catch (std::exception& e) {
59937       {
59938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59939       };
59940     } catch (...) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59943       };
59944     }
59945   }
59946
59947   //argout typemap for const std::string&
59948
59949 }
59950
59951
59952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59953   char * jresult ;
59954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59955   std::string *result = 0 ;
59956
59957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59958   {
59959     try {
59960       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59961     } catch (std::out_of_range& e) {
59962       {
59963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59964       };
59965     } catch (std::exception& e) {
59966       {
59967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (...) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59972       };
59973     }
59974   }
59975   jresult = SWIG_csharp_string_callback(result->c_str());
59976   return jresult;
59977 }
59978
59979
59980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59982   Dali::Vector4 *arg2 = 0 ;
59983
59984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59985   arg2 = (Dali::Vector4 *)jarg2;
59986   if (!arg2) {
59987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59988     return ;
59989   }
59990   {
59991     try {
59992       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59993     } catch (std::out_of_range& e) {
59994       {
59995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59996       };
59997     } catch (std::exception& e) {
59998       {
59999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60000       };
60001     } catch (...) {
60002       {
60003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60004       };
60005     }
60006   }
60007 }
60008
60009
60010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60011   void * jresult ;
60012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60013   Dali::Vector4 result;
60014
60015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60016   {
60017     try {
60018       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60019     } catch (std::out_of_range& e) {
60020       {
60021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60022       };
60023     } catch (std::exception& e) {
60024       {
60025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60026       };
60027     } catch (...) {
60028       {
60029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60030       };
60031     }
60032   }
60033   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60034   return jresult;
60035 }
60036
60037
60038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60040   Dali::Image arg2 ;
60041   Dali::Image *argp2 ;
60042
60043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60044   argp2 = (Dali::Image *)jarg2;
60045   if (!argp2) {
60046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60047     return ;
60048   }
60049   arg2 = *argp2;
60050   {
60051     try {
60052       (arg1)->SetBackgroundImage(arg2);
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60060       };
60061     } catch (...) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60064       };
60065     }
60066   }
60067 }
60068
60069
60070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60072   Dali::Property::Map *arg2 = 0 ;
60073
60074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60075   arg2 = (Dali::Property::Map *)jarg2;
60076   if (!arg2) {
60077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60078     return ;
60079   }
60080   {
60081     try {
60082       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60083     } catch (std::out_of_range& e) {
60084       {
60085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60086       };
60087     } catch (std::exception& e) {
60088       {
60089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60090       };
60091     } catch (...) {
60092       {
60093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60094       };
60095     }
60096   }
60097 }
60098
60099
60100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60101   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60102
60103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60104   {
60105     try {
60106       (arg1)->ClearBackground();
60107     } catch (std::out_of_range& e) {
60108       {
60109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60110       };
60111     } catch (std::exception& e) {
60112       {
60113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60114       };
60115     } catch (...) {
60116       {
60117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60118       };
60119     }
60120   }
60121 }
60122
60123
60124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60126   Dali::Gesture::Type arg2 ;
60127
60128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60129   arg2 = (Dali::Gesture::Type)jarg2;
60130   {
60131     try {
60132       (arg1)->EnableGestureDetection(arg2);
60133     } catch (std::out_of_range& e) {
60134       {
60135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60136       };
60137     } catch (std::exception& e) {
60138       {
60139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60140       };
60141     } catch (...) {
60142       {
60143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60144       };
60145     }
60146   }
60147 }
60148
60149
60150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60152   Dali::Gesture::Type arg2 ;
60153
60154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60155   arg2 = (Dali::Gesture::Type)jarg2;
60156   {
60157     try {
60158       (arg1)->DisableGestureDetection(arg2);
60159     } catch (std::out_of_range& e) {
60160       {
60161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60162       };
60163     } catch (std::exception& e) {
60164       {
60165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60166       };
60167     } catch (...) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60170       };
60171     }
60172   }
60173 }
60174
60175
60176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60177   void * jresult ;
60178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60179   Dali::PinchGestureDetector result;
60180
60181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60182   {
60183     try {
60184       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60185     } catch (std::out_of_range& e) {
60186       {
60187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60188       };
60189     } catch (std::exception& e) {
60190       {
60191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60192       };
60193     } catch (...) {
60194       {
60195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60196       };
60197     }
60198   }
60199   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60200   return jresult;
60201 }
60202
60203
60204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60205   void * jresult ;
60206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60207   Dali::PanGestureDetector result;
60208
60209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60210   {
60211     try {
60212       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60213     } catch (std::out_of_range& e) {
60214       {
60215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60216       };
60217     } catch (std::exception& e) {
60218       {
60219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (...) {
60222       {
60223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60224       };
60225     }
60226   }
60227   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60228   return jresult;
60229 }
60230
60231
60232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60233   void * jresult ;
60234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60235   Dali::TapGestureDetector result;
60236
60237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60238   {
60239     try {
60240       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60241     } catch (std::out_of_range& e) {
60242       {
60243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60244       };
60245     } catch (std::exception& e) {
60246       {
60247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60248       };
60249     } catch (...) {
60250       {
60251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60252       };
60253     }
60254   }
60255   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60256   return jresult;
60257 }
60258
60259
60260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60261   void * jresult ;
60262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60263   Dali::LongPressGestureDetector result;
60264
60265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60266   {
60267     try {
60268       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60280       };
60281     }
60282   }
60283   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60284   return jresult;
60285 }
60286
60287
60288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60290   bool arg2 ;
60291
60292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60293   arg2 = jarg2 ? true : false;
60294   {
60295     try {
60296       (arg1)->SetKeyboardNavigationSupport(arg2);
60297     } catch (std::out_of_range& e) {
60298       {
60299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60300       };
60301     } catch (std::exception& e) {
60302       {
60303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60304       };
60305     } catch (...) {
60306       {
60307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60308       };
60309     }
60310   }
60311 }
60312
60313
60314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60315   unsigned int jresult ;
60316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60317   bool result;
60318
60319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60320   {
60321     try {
60322       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60323     } catch (std::out_of_range& e) {
60324       {
60325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60326       };
60327     } catch (std::exception& e) {
60328       {
60329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (...) {
60332       {
60333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60334       };
60335     }
60336   }
60337   jresult = result;
60338   return jresult;
60339 }
60340
60341
60342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60344
60345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60346   {
60347     try {
60348       (arg1)->SetKeyInputFocus();
60349     } catch (std::out_of_range& e) {
60350       {
60351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60352       };
60353     } catch (std::exception& e) {
60354       {
60355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60356       };
60357     } catch (...) {
60358       {
60359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60360       };
60361     }
60362   }
60363 }
60364
60365
60366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60367   unsigned int jresult ;
60368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60369   bool result;
60370
60371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60372   {
60373     try {
60374       result = (bool)(arg1)->HasKeyInputFocus();
60375     } catch (std::out_of_range& e) {
60376       {
60377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60378       };
60379     } catch (std::exception& e) {
60380       {
60381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60382       };
60383     } catch (...) {
60384       {
60385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60386       };
60387     }
60388   }
60389   jresult = result;
60390   return jresult;
60391 }
60392
60393
60394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60396
60397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60398   {
60399     try {
60400       (arg1)->ClearKeyInputFocus();
60401     } catch (std::out_of_range& e) {
60402       {
60403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60404       };
60405     } catch (std::exception& e) {
60406       {
60407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60412       };
60413     }
60414   }
60415 }
60416
60417
60418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60420   bool arg2 ;
60421
60422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60423   arg2 = jarg2 ? true : false;
60424   {
60425     try {
60426       (arg1)->SetAsKeyboardFocusGroup(arg2);
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60434       };
60435     } catch (...) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60438       };
60439     }
60440   }
60441 }
60442
60443
60444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60445   unsigned int jresult ;
60446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60447   bool result;
60448
60449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60450   {
60451     try {
60452       result = (bool)(arg1)->IsKeyboardFocusGroup();
60453     } catch (std::out_of_range& e) {
60454       {
60455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60456       };
60457     } catch (std::exception& e) {
60458       {
60459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60460       };
60461     } catch (...) {
60462       {
60463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60464       };
60465     }
60466   }
60467   jresult = result;
60468   return jresult;
60469 }
60470
60471
60472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60474
60475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60476   {
60477     try {
60478       (arg1)->AccessibilityActivate();
60479     } catch (std::out_of_range& e) {
60480       {
60481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60482       };
60483     } catch (std::exception& e) {
60484       {
60485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60486       };
60487     } catch (...) {
60488       {
60489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60490       };
60491     }
60492   }
60493 }
60494
60495
60496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60498
60499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60500   {
60501     try {
60502       (arg1)->KeyboardEnter();
60503     } catch (std::out_of_range& e) {
60504       {
60505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60506       };
60507     } catch (std::exception& e) {
60508       {
60509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60510       };
60511     } catch (...) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60514       };
60515     }
60516   }
60517 }
60518
60519
60520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60521   void * jresult ;
60522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60523   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60524
60525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60526   {
60527     try {
60528       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60529     } catch (std::out_of_range& e) {
60530       {
60531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60532       };
60533     } catch (std::exception& e) {
60534       {
60535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60536       };
60537     } catch (...) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60540       };
60541     }
60542   }
60543   jresult = (void *)result;
60544   return jresult;
60545 }
60546
60547
60548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60549   void * jresult ;
60550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60551   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60552
60553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60554   {
60555     try {
60556       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60557     } catch (std::out_of_range& e) {
60558       {
60559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (std::exception& e) {
60562       {
60563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60564       };
60565     } catch (...) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60568       };
60569     }
60570   }
60571   jresult = (void *)result;
60572   return jresult;
60573 }
60574
60575
60576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60577   void * jresult ;
60578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60579   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60580
60581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60582   {
60583     try {
60584       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60585     } catch (std::out_of_range& e) {
60586       {
60587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60588       };
60589     } catch (std::exception& e) {
60590       {
60591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60592       };
60593     } catch (...) {
60594       {
60595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60596       };
60597     }
60598   }
60599   jresult = (void *)result;
60600   return jresult;
60601 }
60602
60603
60604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60605   unsigned int jresult ;
60606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60607   Dali::KeyEvent *arg2 = 0 ;
60608   bool result;
60609
60610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60611   arg2 = (Dali::KeyEvent *)jarg2;
60612   if (!arg2) {
60613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60614     return 0;
60615   }
60616   {
60617     try {
60618       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60619     } catch (std::out_of_range& e) {
60620       {
60621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (std::exception& e) {
60624       {
60625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633   jresult = result;
60634   return jresult;
60635 }
60636
60637
60638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60640   int arg2 ;
60641   SwigDirector_ViewImpl *darg = 0;
60642
60643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60644   arg2 = (int)jarg2;
60645   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60646   {
60647     try {
60648       (darg)->OnStageConnection(arg2);
60649     } catch (std::out_of_range& e) {
60650       {
60651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60652       };
60653     } catch (std::exception& e) {
60654       {
60655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60656       };
60657     } catch (...) {
60658       {
60659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60660       };
60661     }
60662   }
60663 }
60664
60665
60666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60668   int arg2 ;
60669   SwigDirector_ViewImpl *darg = 0;
60670
60671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60672   arg2 = (int)jarg2;
60673   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60674   {
60675     try {
60676       (darg)->OnStageConnectionSwigPublic(arg2);
60677     } catch (std::out_of_range& e) {
60678       {
60679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60680       };
60681     } catch (std::exception& e) {
60682       {
60683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60684       };
60685     } catch (...) {
60686       {
60687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60688       };
60689     }
60690   }
60691 }
60692
60693
60694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60695   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60696   SwigDirector_ViewImpl *darg = 0;
60697
60698   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60700   {
60701     try {
60702       (darg)->OnStageDisconnection();
60703     } catch (std::out_of_range& e) {
60704       {
60705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60706       };
60707     } catch (std::exception& e) {
60708       {
60709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60710       };
60711     } catch (...) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60714       };
60715     }
60716   }
60717 }
60718
60719
60720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60722   SwigDirector_ViewImpl *darg = 0;
60723
60724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60726   {
60727     try {
60728       (darg)->OnStageDisconnectionSwigPublic();
60729     } catch (std::out_of_range& e) {
60730       {
60731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60732       };
60733     } catch (std::exception& e) {
60734       {
60735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60736       };
60737     } catch (...) {
60738       {
60739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60740       };
60741     }
60742   }
60743 }
60744
60745
60746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60748   Dali::Actor *arg2 = 0 ;
60749   SwigDirector_ViewImpl *darg = 0;
60750
60751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60752   arg2 = (Dali::Actor *)jarg2;
60753   if (!arg2) {
60754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60755     return ;
60756   }
60757   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60758   {
60759     try {
60760       (darg)->OnChildAdd(*arg2);
60761     } catch (std::out_of_range& e) {
60762       {
60763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60764       };
60765     } catch (std::exception& e) {
60766       {
60767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60768       };
60769     } catch (...) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60772       };
60773     }
60774   }
60775 }
60776
60777
60778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60780   Dali::Actor *arg2 = 0 ;
60781   SwigDirector_ViewImpl *darg = 0;
60782
60783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60784   arg2 = (Dali::Actor *)jarg2;
60785   if (!arg2) {
60786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60787     return ;
60788   }
60789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60790   {
60791     try {
60792       (darg)->OnChildAddSwigPublic(*arg2);
60793     } catch (std::out_of_range& e) {
60794       {
60795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60796       };
60797     } catch (std::exception& e) {
60798       {
60799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60800       };
60801     } catch (...) {
60802       {
60803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60804       };
60805     }
60806   }
60807 }
60808
60809
60810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60812   Dali::Actor *arg2 = 0 ;
60813   SwigDirector_ViewImpl *darg = 0;
60814
60815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60816   arg2 = (Dali::Actor *)jarg2;
60817   if (!arg2) {
60818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60819     return ;
60820   }
60821   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60822   {
60823     try {
60824       (darg)->OnChildRemove(*arg2);
60825     } catch (std::out_of_range& e) {
60826       {
60827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60828       };
60829     } catch (std::exception& e) {
60830       {
60831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60832       };
60833     } catch (...) {
60834       {
60835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60836       };
60837     }
60838   }
60839 }
60840
60841
60842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60844   Dali::Actor *arg2 = 0 ;
60845   SwigDirector_ViewImpl *darg = 0;
60846
60847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60848   arg2 = (Dali::Actor *)jarg2;
60849   if (!arg2) {
60850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60851     return ;
60852   }
60853   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60854   {
60855     try {
60856       (darg)->OnChildRemoveSwigPublic(*arg2);
60857     } catch (std::out_of_range& e) {
60858       {
60859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60860       };
60861     } catch (std::exception& e) {
60862       {
60863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60868       };
60869     }
60870   }
60871 }
60872
60873
60874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60876   Dali::Property::Index arg2 ;
60877   Dali::Property::Value arg3 ;
60878   Dali::Property::Value *argp3 ;
60879   SwigDirector_ViewImpl *darg = 0;
60880
60881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60882   arg2 = (Dali::Property::Index)jarg2;
60883   argp3 = (Dali::Property::Value *)jarg3;
60884   if (!argp3) {
60885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60886     return ;
60887   }
60888   arg3 = *argp3;
60889   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60890   {
60891     try {
60892       (darg)->OnPropertySet(arg2,arg3);
60893     } catch (std::out_of_range& e) {
60894       {
60895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60896       };
60897     } catch (std::exception& e) {
60898       {
60899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60900       };
60901     } catch (...) {
60902       {
60903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60904       };
60905     }
60906   }
60907 }
60908
60909
60910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60912   Dali::Property::Index arg2 ;
60913   Dali::Property::Value arg3 ;
60914   Dali::Property::Value *argp3 ;
60915   SwigDirector_ViewImpl *darg = 0;
60916
60917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60918   arg2 = (Dali::Property::Index)jarg2;
60919   argp3 = (Dali::Property::Value *)jarg3;
60920   if (!argp3) {
60921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60922     return ;
60923   }
60924   arg3 = *argp3;
60925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60926   {
60927     try {
60928       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60929     } catch (std::out_of_range& e) {
60930       {
60931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60932       };
60933     } catch (std::exception& e) {
60934       {
60935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60936       };
60937     } catch (...) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60940       };
60941     }
60942   }
60943 }
60944
60945
60946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60948   Dali::Vector3 *arg2 = 0 ;
60949   SwigDirector_ViewImpl *darg = 0;
60950
60951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60952   arg2 = (Dali::Vector3 *)jarg2;
60953   if (!arg2) {
60954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60955     return ;
60956   }
60957   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60958   {
60959     try {
60960       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60961     } catch (std::out_of_range& e) {
60962       {
60963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60964       };
60965     } catch (std::exception& e) {
60966       {
60967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60968       };
60969     } catch (...) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60972       };
60973     }
60974   }
60975 }
60976
60977
60978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60980   Dali::Vector3 *arg2 = 0 ;
60981   SwigDirector_ViewImpl *darg = 0;
60982
60983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60984   arg2 = (Dali::Vector3 *)jarg2;
60985   if (!arg2) {
60986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60987     return ;
60988   }
60989   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60990   {
60991     try {
60992       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60993     } catch (std::out_of_range& e) {
60994       {
60995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60996       };
60997     } catch (std::exception& e) {
60998       {
60999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61000       };
61001     } catch (...) {
61002       {
61003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61004       };
61005     }
61006   }
61007 }
61008
61009
61010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61012   Dali::Animation *arg2 = 0 ;
61013   Dali::Vector3 *arg3 = 0 ;
61014   SwigDirector_ViewImpl *darg = 0;
61015
61016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61017   arg2 = (Dali::Animation *)jarg2;
61018   if (!arg2) {
61019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61020     return ;
61021   }
61022   arg3 = (Dali::Vector3 *)jarg3;
61023   if (!arg3) {
61024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61025     return ;
61026   }
61027   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61028   {
61029     try {
61030       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61031     } catch (std::out_of_range& e) {
61032       {
61033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61034       };
61035     } catch (std::exception& e) {
61036       {
61037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61038       };
61039     } catch (...) {
61040       {
61041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61042       };
61043     }
61044   }
61045 }
61046
61047
61048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61050   Dali::Animation *arg2 = 0 ;
61051   Dali::Vector3 *arg3 = 0 ;
61052   SwigDirector_ViewImpl *darg = 0;
61053
61054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61055   arg2 = (Dali::Animation *)jarg2;
61056   if (!arg2) {
61057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61058     return ;
61059   }
61060   arg3 = (Dali::Vector3 *)jarg3;
61061   if (!arg3) {
61062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61063     return ;
61064   }
61065   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61066   {
61067     try {
61068       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61069     } catch (std::out_of_range& e) {
61070       {
61071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61072       };
61073     } catch (std::exception& e) {
61074       {
61075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61076       };
61077     } catch (...) {
61078       {
61079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61080       };
61081     }
61082   }
61083 }
61084
61085
61086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61087   unsigned int jresult ;
61088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61089   Dali::TouchEvent *arg2 = 0 ;
61090   SwigDirector_ViewImpl *darg = 0;
61091   bool result;
61092
61093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61094   arg2 = (Dali::TouchEvent *)jarg2;
61095   if (!arg2) {
61096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61097     return 0;
61098   }
61099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61100   {
61101     try {
61102       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (...) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61114       };
61115     }
61116   }
61117   jresult = result;
61118   return jresult;
61119 }
61120
61121
61122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61123   unsigned int jresult ;
61124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61125   Dali::TouchEvent *arg2 = 0 ;
61126   SwigDirector_ViewImpl *darg = 0;
61127   bool result;
61128
61129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61130   arg2 = (Dali::TouchEvent *)jarg2;
61131   if (!arg2) {
61132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61133     return 0;
61134   }
61135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61136   {
61137     try {
61138       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61139     } catch (std::out_of_range& e) {
61140       {
61141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61142       };
61143     } catch (std::exception& e) {
61144       {
61145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61146       };
61147     } catch (...) {
61148       {
61149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61150       };
61151     }
61152   }
61153   jresult = result;
61154   return jresult;
61155 }
61156
61157
61158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61159   unsigned int jresult ;
61160   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61161   Dali::HoverEvent *arg2 = 0 ;
61162   SwigDirector_ViewImpl *darg = 0;
61163   bool result;
61164
61165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61166   arg2 = (Dali::HoverEvent *)jarg2;
61167   if (!arg2) {
61168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61169     return 0;
61170   }
61171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61172   {
61173     try {
61174       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61186       };
61187     }
61188   }
61189   jresult = result;
61190   return jresult;
61191 }
61192
61193
61194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61195   unsigned int jresult ;
61196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61197   Dali::HoverEvent *arg2 = 0 ;
61198   SwigDirector_ViewImpl *darg = 0;
61199   bool result;
61200
61201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61202   arg2 = (Dali::HoverEvent *)jarg2;
61203   if (!arg2) {
61204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61205     return 0;
61206   }
61207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61208   {
61209     try {
61210       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61211     } catch (std::out_of_range& e) {
61212       {
61213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61214       };
61215     } catch (std::exception& e) {
61216       {
61217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61218       };
61219     } catch (...) {
61220       {
61221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61222       };
61223     }
61224   }
61225   jresult = result;
61226   return jresult;
61227 }
61228
61229
61230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61231   unsigned int jresult ;
61232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61233   Dali::KeyEvent *arg2 = 0 ;
61234   SwigDirector_ViewImpl *darg = 0;
61235   bool result;
61236
61237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61238   arg2 = (Dali::KeyEvent *)jarg2;
61239   if (!arg2) {
61240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61241     return 0;
61242   }
61243   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61244   {
61245     try {
61246       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61247     } catch (std::out_of_range& e) {
61248       {
61249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (std::exception& e) {
61252       {
61253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61254       };
61255     } catch (...) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61258       };
61259     }
61260   }
61261   jresult = result;
61262   return jresult;
61263 }
61264
61265
61266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61267   unsigned int jresult ;
61268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61269   Dali::KeyEvent *arg2 = 0 ;
61270   SwigDirector_ViewImpl *darg = 0;
61271   bool result;
61272
61273   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61274   arg2 = (Dali::KeyEvent *)jarg2;
61275   if (!arg2) {
61276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61277     return 0;
61278   }
61279   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61280   {
61281     try {
61282       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61283     } catch (std::out_of_range& e) {
61284       {
61285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61286       };
61287     } catch (std::exception& e) {
61288       {
61289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (...) {
61292       {
61293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61294       };
61295     }
61296   }
61297   jresult = result;
61298   return jresult;
61299 }
61300
61301
61302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61303   unsigned int jresult ;
61304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61305   Dali::WheelEvent *arg2 = 0 ;
61306   SwigDirector_ViewImpl *darg = 0;
61307   bool result;
61308
61309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61310   arg2 = (Dali::WheelEvent *)jarg2;
61311   if (!arg2) {
61312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61313     return 0;
61314   }
61315   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61316   {
61317     try {
61318       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61319     } catch (std::out_of_range& e) {
61320       {
61321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (std::exception& e) {
61324       {
61325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61326       };
61327     } catch (...) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61330       };
61331     }
61332   }
61333   jresult = result;
61334   return jresult;
61335 }
61336
61337
61338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61339   unsigned int jresult ;
61340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61341   Dali::WheelEvent *arg2 = 0 ;
61342   SwigDirector_ViewImpl *darg = 0;
61343   bool result;
61344
61345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61346   arg2 = (Dali::WheelEvent *)jarg2;
61347   if (!arg2) {
61348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61349     return 0;
61350   }
61351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61352   {
61353     try {
61354       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61355     } catch (std::out_of_range& e) {
61356       {
61357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61358       };
61359     } catch (std::exception& e) {
61360       {
61361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61362       };
61363     } catch (...) {
61364       {
61365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61366       };
61367     }
61368   }
61369   jresult = result;
61370   return jresult;
61371 }
61372
61373
61374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61376   Dali::Vector2 *arg2 = 0 ;
61377   Dali::RelayoutContainer *arg3 = 0 ;
61378   SwigDirector_ViewImpl *darg = 0;
61379
61380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61381   arg2 = (Dali::Vector2 *)jarg2;
61382   if (!arg2) {
61383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61384     return ;
61385   }
61386   arg3 = (Dali::RelayoutContainer *)jarg3;
61387   if (!arg3) {
61388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61389     return ;
61390   }
61391   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61392   {
61393     try {
61394       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61395     } catch (std::out_of_range& e) {
61396       {
61397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61398       };
61399     } catch (std::exception& e) {
61400       {
61401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61402       };
61403     } catch (...) {
61404       {
61405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61406       };
61407     }
61408   }
61409 }
61410
61411
61412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61414   Dali::Vector2 *arg2 = 0 ;
61415   Dali::RelayoutContainer *arg3 = 0 ;
61416   SwigDirector_ViewImpl *darg = 0;
61417
61418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61419   arg2 = (Dali::Vector2 *)jarg2;
61420   if (!arg2) {
61421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61422     return ;
61423   }
61424   arg3 = (Dali::RelayoutContainer *)jarg3;
61425   if (!arg3) {
61426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61427     return ;
61428   }
61429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61430   {
61431     try {
61432       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61433     } catch (std::out_of_range& e) {
61434       {
61435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61436       };
61437     } catch (std::exception& e) {
61438       {
61439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61440       };
61441     } catch (...) {
61442       {
61443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61444       };
61445     }
61446   }
61447 }
61448
61449
61450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61452   Dali::ResizePolicy::Type arg2 ;
61453   Dali::Dimension::Type arg3 ;
61454   SwigDirector_ViewImpl *darg = 0;
61455
61456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61457   arg2 = (Dali::ResizePolicy::Type)jarg2;
61458   arg3 = (Dali::Dimension::Type)jarg3;
61459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61460   {
61461     try {
61462       (darg)->OnSetResizePolicy(arg2,arg3);
61463     } catch (std::out_of_range& e) {
61464       {
61465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (std::exception& e) {
61468       {
61469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61470       };
61471     } catch (...) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61474       };
61475     }
61476   }
61477 }
61478
61479
61480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61481   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61482   Dali::ResizePolicy::Type arg2 ;
61483   Dali::Dimension::Type arg3 ;
61484   SwigDirector_ViewImpl *darg = 0;
61485
61486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61487   arg2 = (Dali::ResizePolicy::Type)jarg2;
61488   arg3 = (Dali::Dimension::Type)jarg3;
61489   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61490   {
61491     try {
61492       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61493     } catch (std::out_of_range& e) {
61494       {
61495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61496       };
61497     } catch (std::exception& e) {
61498       {
61499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61500       };
61501     } catch (...) {
61502       {
61503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61504       };
61505     }
61506   }
61507 }
61508
61509
61510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61511   void * jresult ;
61512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61513   SwigDirector_ViewImpl *darg = 0;
61514   Dali::Vector3 result;
61515
61516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61518   {
61519     try {
61520       result = (darg)->GetNaturalSize();
61521     } catch (std::out_of_range& e) {
61522       {
61523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61524       };
61525     } catch (std::exception& e) {
61526       {
61527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61528       };
61529     } catch (...) {
61530       {
61531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61532       };
61533     }
61534   }
61535   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61536   return jresult;
61537 }
61538
61539
61540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61541   void * jresult ;
61542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61543   SwigDirector_ViewImpl *darg = 0;
61544   Dali::Vector3 result;
61545
61546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61548   {
61549     try {
61550       result = (darg)->GetNaturalSizeSwigPublic();
61551     } catch (std::out_of_range& e) {
61552       {
61553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61554       };
61555     } catch (std::exception& e) {
61556       {
61557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61558       };
61559     } catch (...) {
61560       {
61561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61562       };
61563     }
61564   }
61565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61566   return jresult;
61567 }
61568
61569
61570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61571   float jresult ;
61572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61573   Dali::Actor *arg2 = 0 ;
61574   Dali::Dimension::Type arg3 ;
61575   SwigDirector_ViewImpl *darg = 0;
61576   float result;
61577
61578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61579   arg2 = (Dali::Actor *)jarg2;
61580   if (!arg2) {
61581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61582     return 0;
61583   }
61584   arg3 = (Dali::Dimension::Type)jarg3;
61585   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61586   {
61587     try {
61588       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61589     } catch (std::out_of_range& e) {
61590       {
61591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61592       };
61593     } catch (std::exception& e) {
61594       {
61595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61596       };
61597     } catch (...) {
61598       {
61599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61600       };
61601     }
61602   }
61603   jresult = result;
61604   return jresult;
61605 }
61606
61607
61608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61609   float jresult ;
61610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61611   Dali::Actor *arg2 = 0 ;
61612   Dali::Dimension::Type arg3 ;
61613   SwigDirector_ViewImpl *darg = 0;
61614   float result;
61615
61616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61617   arg2 = (Dali::Actor *)jarg2;
61618   if (!arg2) {
61619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61620     return 0;
61621   }
61622   arg3 = (Dali::Dimension::Type)jarg3;
61623   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61624   {
61625     try {
61626       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61627     } catch (std::out_of_range& e) {
61628       {
61629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61630       };
61631     } catch (std::exception& e) {
61632       {
61633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61634       };
61635     } catch (...) {
61636       {
61637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61638       };
61639     }
61640   }
61641   jresult = result;
61642   return jresult;
61643 }
61644
61645
61646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61647   float jresult ;
61648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61649   float arg2 ;
61650   SwigDirector_ViewImpl *darg = 0;
61651   float result;
61652
61653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61654   arg2 = (float)jarg2;
61655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61656   {
61657     try {
61658       result = (float)(darg)->GetHeightForWidth(arg2);
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61666       };
61667     } catch (...) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61670       };
61671     }
61672   }
61673   jresult = result;
61674   return jresult;
61675 }
61676
61677
61678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61679   float jresult ;
61680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61681   float arg2 ;
61682   SwigDirector_ViewImpl *darg = 0;
61683   float result;
61684
61685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61686   arg2 = (float)jarg2;
61687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61688   {
61689     try {
61690       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61691     } catch (std::out_of_range& e) {
61692       {
61693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61694       };
61695     } catch (std::exception& e) {
61696       {
61697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61698       };
61699     } catch (...) {
61700       {
61701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61702       };
61703     }
61704   }
61705   jresult = result;
61706   return jresult;
61707 }
61708
61709
61710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61711   float jresult ;
61712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61713   float arg2 ;
61714   SwigDirector_ViewImpl *darg = 0;
61715   float result;
61716
61717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61718   arg2 = (float)jarg2;
61719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61720   {
61721     try {
61722       result = (float)(darg)->GetWidthForHeight(arg2);
61723     } catch (std::out_of_range& e) {
61724       {
61725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61726       };
61727     } catch (std::exception& e) {
61728       {
61729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61730       };
61731     } catch (...) {
61732       {
61733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61734       };
61735     }
61736   }
61737   jresult = result;
61738   return jresult;
61739 }
61740
61741
61742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61743   float jresult ;
61744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61745   float arg2 ;
61746   SwigDirector_ViewImpl *darg = 0;
61747   float result;
61748
61749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61750   arg2 = (float)jarg2;
61751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61752   {
61753     try {
61754       result = (float)(darg)->GetWidthForHeightSwigPublic(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 (...) {
61764       {
61765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61766       };
61767     }
61768   }
61769   jresult = result;
61770   return jresult;
61771 }
61772
61773
61774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61775   unsigned int jresult ;
61776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61777   Dali::Dimension::Type arg2 ;
61778   SwigDirector_ViewImpl *darg = 0;
61779   bool result;
61780
61781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61782   arg2 = (Dali::Dimension::Type)jarg2;
61783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61784   {
61785     try {
61786       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61787     } catch (std::out_of_range& e) {
61788       {
61789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61790       };
61791     } catch (std::exception& e) {
61792       {
61793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61794       };
61795     } catch (...) {
61796       {
61797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61798       };
61799     }
61800   }
61801   jresult = result;
61802   return jresult;
61803 }
61804
61805
61806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61807   unsigned int jresult ;
61808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61809   Dali::Dimension::Type arg2 ;
61810   SwigDirector_ViewImpl *darg = 0;
61811   bool result;
61812
61813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61814   arg2 = (Dali::Dimension::Type)jarg2;
61815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61816   {
61817     try {
61818       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61819     } catch (std::out_of_range& e) {
61820       {
61821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61822       };
61823     } catch (std::exception& e) {
61824       {
61825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61826       };
61827     } catch (...) {
61828       {
61829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61830       };
61831     }
61832   }
61833   jresult = result;
61834   return jresult;
61835 }
61836
61837
61838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61839   unsigned int jresult ;
61840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61841   SwigDirector_ViewImpl *darg = 0;
61842   bool result;
61843
61844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61845   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61846   {
61847     try {
61848       result = (bool)(darg)->RelayoutDependentOnChildren();
61849     } catch (std::out_of_range& e) {
61850       {
61851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61852       };
61853     } catch (std::exception& e) {
61854       {
61855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61856       };
61857     } catch (...) {
61858       {
61859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61860       };
61861     }
61862   }
61863   jresult = result;
61864   return jresult;
61865 }
61866
61867
61868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61869   unsigned int jresult ;
61870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61871   SwigDirector_ViewImpl *darg = 0;
61872   bool result;
61873
61874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61875   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61876   {
61877     try {
61878       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61879     } catch (std::out_of_range& e) {
61880       {
61881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61882       };
61883     } catch (std::exception& e) {
61884       {
61885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61886       };
61887     } catch (...) {
61888       {
61889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61890       };
61891     }
61892   }
61893   jresult = result;
61894   return jresult;
61895 }
61896
61897
61898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61900   Dali::Dimension::Type arg2 ;
61901   SwigDirector_ViewImpl *darg = 0;
61902
61903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61904   arg2 = (Dali::Dimension::Type)jarg2;
61905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61906   {
61907     try {
61908       (darg)->OnCalculateRelayoutSize(arg2);
61909     } catch (std::out_of_range& e) {
61910       {
61911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61912       };
61913     } catch (std::exception& e) {
61914       {
61915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61916       };
61917     } catch (...) {
61918       {
61919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61920       };
61921     }
61922   }
61923 }
61924
61925
61926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61928   Dali::Dimension::Type arg2 ;
61929   SwigDirector_ViewImpl *darg = 0;
61930
61931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61932   arg2 = (Dali::Dimension::Type)jarg2;
61933   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61934   {
61935     try {
61936       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61937     } catch (std::out_of_range& e) {
61938       {
61939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61940       };
61941     } catch (std::exception& e) {
61942       {
61943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61948       };
61949     }
61950   }
61951 }
61952
61953
61954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61956   float arg2 ;
61957   Dali::Dimension::Type arg3 ;
61958   SwigDirector_ViewImpl *darg = 0;
61959
61960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61961   arg2 = (float)jarg2;
61962   arg3 = (Dali::Dimension::Type)jarg3;
61963   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61964   {
61965     try {
61966       (darg)->OnLayoutNegotiated(arg2,arg3);
61967     } catch (std::out_of_range& e) {
61968       {
61969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61970       };
61971     } catch (std::exception& e) {
61972       {
61973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61974       };
61975     } catch (...) {
61976       {
61977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61978       };
61979     }
61980   }
61981 }
61982
61983
61984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61986   float arg2 ;
61987   Dali::Dimension::Type arg3 ;
61988   SwigDirector_ViewImpl *darg = 0;
61989
61990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61991   arg2 = (float)jarg2;
61992   arg3 = (Dali::Dimension::Type)jarg3;
61993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61994   {
61995     try {
61996       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61997     } catch (std::out_of_range& e) {
61998       {
61999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62000       };
62001     } catch (std::exception& e) {
62002       {
62003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62004       };
62005     } catch (...) {
62006       {
62007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62008       };
62009     }
62010   }
62011 }
62012
62013
62014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62016
62017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62018   {
62019     try {
62020       (arg1)->OnInitialize();
62021     } catch (std::out_of_range& e) {
62022       {
62023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62024       };
62025     } catch (std::exception& e) {
62026       {
62027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62028       };
62029     } catch (...) {
62030       {
62031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62032       };
62033     }
62034   }
62035 }
62036
62037
62038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62040
62041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62042   {
62043     try {
62044       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62045     } catch (std::out_of_range& e) {
62046       {
62047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62048       };
62049     } catch (std::exception& e) {
62050       {
62051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62052       };
62053     } catch (...) {
62054       {
62055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62056       };
62057     }
62058   }
62059 }
62060
62061
62062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62064   Dali::Actor *arg2 = 0 ;
62065
62066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62067   arg2 = (Dali::Actor *)jarg2;
62068   if (!arg2) {
62069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62070     return ;
62071   }
62072   {
62073     try {
62074       (arg1)->OnControlChildAdd(*arg2);
62075     } catch (std::out_of_range& e) {
62076       {
62077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62078       };
62079     } catch (std::exception& e) {
62080       {
62081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62082       };
62083     } catch (...) {
62084       {
62085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62086       };
62087     }
62088   }
62089 }
62090
62091
62092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62094   Dali::Actor *arg2 = 0 ;
62095
62096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62097   arg2 = (Dali::Actor *)jarg2;
62098   if (!arg2) {
62099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62100     return ;
62101   }
62102   {
62103     try {
62104       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62105     } catch (std::out_of_range& e) {
62106       {
62107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62108       };
62109     } catch (std::exception& e) {
62110       {
62111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62112       };
62113     } catch (...) {
62114       {
62115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62116       };
62117     }
62118   }
62119 }
62120
62121
62122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62124   Dali::Actor *arg2 = 0 ;
62125
62126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62127   arg2 = (Dali::Actor *)jarg2;
62128   if (!arg2) {
62129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62130     return ;
62131   }
62132   {
62133     try {
62134       (arg1)->OnControlChildRemove(*arg2);
62135     } catch (std::out_of_range& e) {
62136       {
62137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62138       };
62139     } catch (std::exception& e) {
62140       {
62141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62142       };
62143     } catch (...) {
62144       {
62145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62146       };
62147     }
62148   }
62149 }
62150
62151
62152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62154   Dali::Actor *arg2 = 0 ;
62155
62156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62157   arg2 = (Dali::Actor *)jarg2;
62158   if (!arg2) {
62159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62160     return ;
62161   }
62162   {
62163     try {
62164       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62165     } catch (std::out_of_range& e) {
62166       {
62167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62168       };
62169     } catch (std::exception& e) {
62170       {
62171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62172       };
62173     } catch (...) {
62174       {
62175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62176       };
62177     }
62178   }
62179 }
62180
62181
62182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62184   Dali::Toolkit::StyleManager arg2 ;
62185   Dali::StyleChange::Type arg3 ;
62186   Dali::Toolkit::StyleManager *argp2 ;
62187
62188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62189   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62190   if (!argp2) {
62191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62192     return ;
62193   }
62194   arg2 = *argp2;
62195   arg3 = (Dali::StyleChange::Type)jarg3;
62196   {
62197     try {
62198       (arg1)->OnStyleChange(arg2,arg3);
62199     } catch (std::out_of_range& e) {
62200       {
62201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62202       };
62203     } catch (std::exception& e) {
62204       {
62205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62206       };
62207     } catch (...) {
62208       {
62209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62210       };
62211     }
62212   }
62213 }
62214
62215
62216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62218   Dali::Toolkit::StyleManager arg2 ;
62219   Dali::StyleChange::Type arg3 ;
62220   Dali::Toolkit::StyleManager *argp2 ;
62221
62222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62223   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62224   if (!argp2) {
62225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62226     return ;
62227   }
62228   arg2 = *argp2;
62229   arg3 = (Dali::StyleChange::Type)jarg3;
62230   {
62231     try {
62232       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62233     } catch (std::out_of_range& e) {
62234       {
62235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62236       };
62237     } catch (std::exception& e) {
62238       {
62239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62240       };
62241     } catch (...) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62244       };
62245     }
62246   }
62247 }
62248
62249
62250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62251   unsigned int jresult ;
62252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62253   bool result;
62254
62255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62256   {
62257     try {
62258       result = (bool)(arg1)->OnAccessibilityActivated();
62259     } catch (std::out_of_range& e) {
62260       {
62261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62262       };
62263     } catch (std::exception& e) {
62264       {
62265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62266       };
62267     } catch (...) {
62268       {
62269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62270       };
62271     }
62272   }
62273   jresult = result;
62274   return jresult;
62275 }
62276
62277
62278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62279   unsigned int jresult ;
62280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62281   bool result;
62282
62283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62284   {
62285     try {
62286       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62287     } catch (std::out_of_range& e) {
62288       {
62289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62290       };
62291     } catch (std::exception& e) {
62292       {
62293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62294       };
62295     } catch (...) {
62296       {
62297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62298       };
62299     }
62300   }
62301   jresult = result;
62302   return jresult;
62303 }
62304
62305
62306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62307   unsigned int jresult ;
62308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62309   Dali::PanGesture arg2 ;
62310   Dali::PanGesture *argp2 ;
62311   bool result;
62312
62313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62314   argp2 = (Dali::PanGesture *)jarg2;
62315   if (!argp2) {
62316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62317     return 0;
62318   }
62319   arg2 = *argp2;
62320   {
62321     try {
62322       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62323     } catch (std::out_of_range& e) {
62324       {
62325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62326       };
62327     } catch (std::exception& e) {
62328       {
62329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62330       };
62331     } catch (...) {
62332       {
62333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62334       };
62335     }
62336   }
62337   jresult = result;
62338   return jresult;
62339 }
62340
62341
62342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62343   unsigned int jresult ;
62344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62345   Dali::PanGesture arg2 ;
62346   Dali::PanGesture *argp2 ;
62347   bool result;
62348
62349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62350   argp2 = (Dali::PanGesture *)jarg2;
62351   if (!argp2) {
62352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62353     return 0;
62354   }
62355   arg2 = *argp2;
62356   {
62357     try {
62358       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62370       };
62371     }
62372   }
62373   jresult = result;
62374   return jresult;
62375 }
62376
62377
62378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62379   unsigned int jresult ;
62380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62381   Dali::TouchEvent *arg2 = 0 ;
62382   bool result;
62383
62384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62385   arg2 = (Dali::TouchEvent *)jarg2;
62386   if (!arg2) {
62387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62388     return 0;
62389   }
62390   {
62391     try {
62392       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62393     } catch (std::out_of_range& e) {
62394       {
62395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (std::exception& e) {
62398       {
62399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (...) {
62402       {
62403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62404       };
62405     }
62406   }
62407   jresult = result;
62408   return jresult;
62409 }
62410
62411
62412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62413   unsigned int jresult ;
62414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62415   Dali::TouchEvent *arg2 = 0 ;
62416   bool result;
62417
62418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62419   arg2 = (Dali::TouchEvent *)jarg2;
62420   if (!arg2) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62422     return 0;
62423   }
62424   {
62425     try {
62426       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62427     } catch (std::out_of_range& e) {
62428       {
62429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (std::exception& e) {
62432       {
62433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (...) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62438       };
62439     }
62440   }
62441   jresult = result;
62442   return jresult;
62443 }
62444
62445
62446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62447   unsigned int jresult ;
62448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62449   bool arg2 ;
62450   bool result;
62451
62452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62453   arg2 = jarg2 ? true : false;
62454   {
62455     try {
62456       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62457     } catch (std::out_of_range& e) {
62458       {
62459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62460       };
62461     } catch (std::exception& e) {
62462       {
62463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62464       };
62465     } catch (...) {
62466       {
62467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62468       };
62469     }
62470   }
62471   jresult = result;
62472   return jresult;
62473 }
62474
62475
62476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62477   unsigned int jresult ;
62478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62479   bool arg2 ;
62480   bool result;
62481
62482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62483   arg2 = jarg2 ? true : false;
62484   {
62485     try {
62486       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62487     } catch (std::out_of_range& e) {
62488       {
62489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62490       };
62491     } catch (std::exception& e) {
62492       {
62493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62494       };
62495     } catch (...) {
62496       {
62497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62498       };
62499     }
62500   }
62501   jresult = result;
62502   return jresult;
62503 }
62504
62505
62506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62507   unsigned int jresult ;
62508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62509   bool result;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   {
62513     try {
62514       result = (bool)(arg1)->OnAccessibilityZoom();
62515     } catch (std::out_of_range& e) {
62516       {
62517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62518       };
62519     } catch (std::exception& e) {
62520       {
62521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62522       };
62523     } catch (...) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62526       };
62527     }
62528   }
62529   jresult = result;
62530   return jresult;
62531 }
62532
62533
62534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62535   unsigned int jresult ;
62536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62537   bool result;
62538
62539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62540   {
62541     try {
62542       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62543     } catch (std::out_of_range& e) {
62544       {
62545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62546       };
62547     } catch (std::exception& e) {
62548       {
62549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62550       };
62551     } catch (...) {
62552       {
62553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62554       };
62555     }
62556   }
62557   jresult = result;
62558   return jresult;
62559 }
62560
62561
62562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62564
62565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62566   {
62567     try {
62568       (arg1)->OnKeyInputFocusGained();
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62576       };
62577     } catch (...) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62580       };
62581     }
62582   }
62583 }
62584
62585
62586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62588
62589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62590   {
62591     try {
62592       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62593     } catch (std::out_of_range& e) {
62594       {
62595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62596       };
62597     } catch (std::exception& e) {
62598       {
62599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62600       };
62601     } catch (...) {
62602       {
62603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62604       };
62605     }
62606   }
62607 }
62608
62609
62610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62612
62613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62614   {
62615     try {
62616       (arg1)->OnKeyInputFocusLost();
62617     } catch (std::out_of_range& e) {
62618       {
62619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62620       };
62621     } catch (std::exception& e) {
62622       {
62623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62624       };
62625     } catch (...) {
62626       {
62627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62628       };
62629     }
62630   }
62631 }
62632
62633
62634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62636
62637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62638   {
62639     try {
62640       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62641     } catch (std::out_of_range& e) {
62642       {
62643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62644       };
62645     } catch (std::exception& e) {
62646       {
62647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62648       };
62649     } catch (...) {
62650       {
62651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62652       };
62653     }
62654   }
62655 }
62656
62657
62658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62659   void * jresult ;
62660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62661   Dali::Actor arg2 ;
62662   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62663   bool arg4 ;
62664   Dali::Actor *argp2 ;
62665   Dali::Actor result;
62666
62667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62668   argp2 = (Dali::Actor *)jarg2;
62669   if (!argp2) {
62670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62671     return 0;
62672   }
62673   arg2 = *argp2;
62674   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62675   arg4 = jarg4 ? true : false;
62676   {
62677     try {
62678       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62679     } catch (std::out_of_range& e) {
62680       {
62681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62682       };
62683     } catch (std::exception& e) {
62684       {
62685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62686       };
62687     } catch (...) {
62688       {
62689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62690       };
62691     }
62692   }
62693   jresult = new Dali::Actor((const Dali::Actor &)result);
62694   return jresult;
62695 }
62696
62697
62698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62699   void * jresult ;
62700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62701   Dali::Actor arg2 ;
62702   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62703   bool arg4 ;
62704   Dali::Actor *argp2 ;
62705   Dali::Actor result;
62706
62707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62708   argp2 = (Dali::Actor *)jarg2;
62709   if (!argp2) {
62710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62711     return 0;
62712   }
62713   arg2 = *argp2;
62714   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62715   arg4 = jarg4 ? true : false;
62716   {
62717     try {
62718       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62719     } catch (std::out_of_range& e) {
62720       {
62721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62722       };
62723     } catch (std::exception& e) {
62724       {
62725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62726       };
62727     } catch (...) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62730       };
62731     }
62732   }
62733   jresult = new Dali::Actor((const Dali::Actor &)result);
62734   return jresult;
62735 }
62736
62737
62738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62740   Dali::Actor arg2 ;
62741   Dali::Actor *argp2 ;
62742
62743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62744   argp2 = (Dali::Actor *)jarg2;
62745   if (!argp2) {
62746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62747     return ;
62748   }
62749   arg2 = *argp2;
62750   {
62751     try {
62752       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62753     } catch (std::out_of_range& e) {
62754       {
62755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62756       };
62757     } catch (std::exception& e) {
62758       {
62759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62760       };
62761     } catch (...) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62764       };
62765     }
62766   }
62767 }
62768
62769
62770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62772   Dali::Actor arg2 ;
62773   Dali::Actor *argp2 ;
62774
62775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62776   argp2 = (Dali::Actor *)jarg2;
62777   if (!argp2) {
62778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62779     return ;
62780   }
62781   arg2 = *argp2;
62782   {
62783     try {
62784       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62785     } catch (std::out_of_range& e) {
62786       {
62787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62788       };
62789     } catch (std::exception& e) {
62790       {
62791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62792       };
62793     } catch (...) {
62794       {
62795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62796       };
62797     }
62798   }
62799 }
62800
62801
62802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62803   unsigned int jresult ;
62804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62805   bool result;
62806
62807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62808   {
62809     try {
62810       result = (bool)(arg1)->OnKeyboardEnter();
62811     } catch (std::out_of_range& e) {
62812       {
62813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (std::exception& e) {
62816       {
62817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62818       };
62819     } catch (...) {
62820       {
62821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62822       };
62823     }
62824   }
62825   jresult = result;
62826   return jresult;
62827 }
62828
62829
62830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62831   unsigned int jresult ;
62832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62833   bool result;
62834
62835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62836   {
62837     try {
62838       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62839     } catch (std::out_of_range& e) {
62840       {
62841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62842       };
62843     } catch (std::exception& e) {
62844       {
62845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62846       };
62847     } catch (...) {
62848       {
62849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62850       };
62851     }
62852   }
62853   jresult = result;
62854   return jresult;
62855 }
62856
62857
62858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62860   Dali::PinchGesture *arg2 = 0 ;
62861
62862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62863   arg2 = (Dali::PinchGesture *)jarg2;
62864   if (!arg2) {
62865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62866     return ;
62867   }
62868   {
62869     try {
62870       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62871     } catch (std::out_of_range& e) {
62872       {
62873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62874       };
62875     } catch (std::exception& e) {
62876       {
62877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62878       };
62879     } catch (...) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62882       };
62883     }
62884   }
62885 }
62886
62887
62888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62890   Dali::PinchGesture *arg2 = 0 ;
62891
62892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62893   arg2 = (Dali::PinchGesture *)jarg2;
62894   if (!arg2) {
62895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62896     return ;
62897   }
62898   {
62899     try {
62900       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62901     } catch (std::out_of_range& e) {
62902       {
62903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62904       };
62905     } catch (std::exception& e) {
62906       {
62907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62908       };
62909     } catch (...) {
62910       {
62911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62912       };
62913     }
62914   }
62915 }
62916
62917
62918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62920   Dali::PanGesture *arg2 = 0 ;
62921
62922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62923   arg2 = (Dali::PanGesture *)jarg2;
62924   if (!arg2) {
62925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62926     return ;
62927   }
62928   {
62929     try {
62930       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62931     } catch (std::out_of_range& e) {
62932       {
62933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62934       };
62935     } catch (std::exception& e) {
62936       {
62937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62938       };
62939     } catch (...) {
62940       {
62941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62942       };
62943     }
62944   }
62945 }
62946
62947
62948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62950   Dali::PanGesture *arg2 = 0 ;
62951
62952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62953   arg2 = (Dali::PanGesture *)jarg2;
62954   if (!arg2) {
62955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62956     return ;
62957   }
62958   {
62959     try {
62960       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62961     } catch (std::out_of_range& e) {
62962       {
62963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62964       };
62965     } catch (std::exception& e) {
62966       {
62967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62968       };
62969     } catch (...) {
62970       {
62971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62972       };
62973     }
62974   }
62975 }
62976
62977
62978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62980   Dali::TapGesture *arg2 = 0 ;
62981
62982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62983   arg2 = (Dali::TapGesture *)jarg2;
62984   if (!arg2) {
62985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62986     return ;
62987   }
62988   {
62989     try {
62990       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62991     } catch (std::out_of_range& e) {
62992       {
62993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62994       };
62995     } catch (std::exception& e) {
62996       {
62997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62998       };
62999     } catch (...) {
63000       {
63001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63002       };
63003     }
63004   }
63005 }
63006
63007
63008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63010   Dali::TapGesture *arg2 = 0 ;
63011
63012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63013   arg2 = (Dali::TapGesture *)jarg2;
63014   if (!arg2) {
63015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63016     return ;
63017   }
63018   {
63019     try {
63020       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63021     } catch (std::out_of_range& e) {
63022       {
63023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63024       };
63025     } catch (std::exception& e) {
63026       {
63027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63028       };
63029     } catch (...) {
63030       {
63031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63032       };
63033     }
63034   }
63035 }
63036
63037
63038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63040   Dali::LongPressGesture *arg2 = 0 ;
63041
63042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63043   arg2 = (Dali::LongPressGesture *)jarg2;
63044   if (!arg2) {
63045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63046     return ;
63047   }
63048   {
63049     try {
63050       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63051     } catch (std::out_of_range& e) {
63052       {
63053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63054       };
63055     } catch (std::exception& e) {
63056       {
63057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63058       };
63059     } catch (...) {
63060       {
63061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63062       };
63063     }
63064   }
63065 }
63066
63067
63068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63070   Dali::LongPressGesture *arg2 = 0 ;
63071
63072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63073   arg2 = (Dali::LongPressGesture *)jarg2;
63074   if (!arg2) {
63075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63076     return ;
63077   }
63078   {
63079     try {
63080       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63081     } catch (std::out_of_range& e) {
63082       {
63083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63084       };
63085     } catch (std::exception& e) {
63086       {
63087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63092       };
63093     }
63094   }
63095 }
63096
63097
63098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63100   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63101   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63102
63103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63104   arg2 = (Dali::SlotObserver *)jarg2;
63105   arg3 = (Dali::CallbackBase *)jarg3;
63106   {
63107     try {
63108       (arg1)->SignalConnected(arg2,arg3);
63109     } catch (std::out_of_range& e) {
63110       {
63111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63112       };
63113     } catch (std::exception& e) {
63114       {
63115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63116       };
63117     } catch (...) {
63118       {
63119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63120       };
63121     }
63122   }
63123 }
63124
63125
63126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63128   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63129   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63130
63131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63132   arg2 = (Dali::SlotObserver *)jarg2;
63133   arg3 = (Dali::CallbackBase *)jarg3;
63134   {
63135     try {
63136       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63137     } catch (std::out_of_range& e) {
63138       {
63139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63140       };
63141     } catch (std::exception& e) {
63142       {
63143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63144       };
63145     } catch (...) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63148       };
63149     }
63150   }
63151 }
63152
63153
63154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63156   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63157   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63158
63159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63160   arg2 = (Dali::SlotObserver *)jarg2;
63161   arg3 = (Dali::CallbackBase *)jarg3;
63162   {
63163     try {
63164       (arg1)->SignalDisconnected(arg2,arg3);
63165     } catch (std::out_of_range& e) {
63166       {
63167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63168       };
63169     } catch (std::exception& e) {
63170       {
63171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63172       };
63173     } catch (...) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63176       };
63177     }
63178   }
63179 }
63180
63181
63182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63183   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63184   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63185   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63186
63187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63188   arg2 = (Dali::SlotObserver *)jarg2;
63189   arg3 = (Dali::CallbackBase *)jarg3;
63190   {
63191     try {
63192       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63193     } catch (std::out_of_range& e) {
63194       {
63195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63196       };
63197     } catch (std::exception& e) {
63198       {
63199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63200       };
63201     } catch (...) {
63202       {
63203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63204       };
63205     }
63206   }
63207 }
63208
63209
63210 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) {
63211   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63212   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63213   if (director) {
63214     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);
63215   }
63216 }
63217
63218
63219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63220   void * jresult ;
63221   Dali::Toolkit::Control *arg1 = 0 ;
63222   Dali::Toolkit::Internal::Control *result = 0 ;
63223
63224   arg1 = (Dali::Toolkit::Control *)jarg1;
63225   if (!arg1) {
63226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63227     return 0;
63228   }
63229   {
63230     try {
63231       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63232     } catch (std::out_of_range& e) {
63233       {
63234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63235       };
63236     } catch (std::exception& e) {
63237       {
63238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63239       };
63240     } catch (...) {
63241       {
63242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63243       };
63244     }
63245   }
63246   jresult = (void *)result;
63247   return jresult;
63248 }
63249
63250
63251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63252   int jresult ;
63253   int result;
63254
63255   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63256   jresult = (int)result;
63257   return jresult;
63258 }
63259
63260
63261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63262   int jresult ;
63263   int result;
63264
63265   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63266   jresult = (int)result;
63267   return jresult;
63268 }
63269
63270
63271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63272   int jresult ;
63273   int result;
63274
63275   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63276   jresult = (int)result;
63277   return jresult;
63278 }
63279
63280
63281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63282   int jresult ;
63283   int result;
63284
63285   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63286   jresult = (int)result;
63287   return jresult;
63288 }
63289
63290
63291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63292   int jresult ;
63293   int result;
63294
63295   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63296   jresult = (int)result;
63297   return jresult;
63298 }
63299
63300
63301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63302   void * jresult ;
63303   Dali::Toolkit::Control::Property *result = 0 ;
63304
63305   {
63306     try {
63307       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63308     } catch (std::out_of_range& e) {
63309       {
63310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63311       };
63312     } catch (std::exception& e) {
63313       {
63314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63315       };
63316     } catch (...) {
63317       {
63318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63319       };
63320     }
63321   }
63322   jresult = (void *)result;
63323   return jresult;
63324 }
63325
63326
63327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63328   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63329
63330   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63331   {
63332     try {
63333       delete arg1;
63334     } catch (std::out_of_range& e) {
63335       {
63336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63337       };
63338     } catch (std::exception& e) {
63339       {
63340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63341       };
63342     } catch (...) {
63343       {
63344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63345       };
63346     }
63347   }
63348 }
63349
63350
63351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63352   void * jresult ;
63353   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63354
63355   {
63356     try {
63357       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63358     } catch (std::out_of_range& e) {
63359       {
63360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63361       };
63362     } catch (std::exception& e) {
63363       {
63364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (...) {
63367       {
63368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63369       };
63370     }
63371   }
63372   jresult = (void *)result;
63373   return jresult;
63374 }
63375
63376
63377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63378   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63379
63380   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63381   {
63382     try {
63383       delete arg1;
63384     } catch (std::out_of_range& e) {
63385       {
63386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63387       };
63388     } catch (std::exception& e) {
63389       {
63390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63391       };
63392     } catch (...) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63395       };
63396     }
63397   }
63398 }
63399
63400
63401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63402   void * jresult ;
63403   Dali::Toolkit::Control result;
63404
63405   {
63406     try {
63407       result = Dali::Toolkit::Control::New();
63408     } catch (std::out_of_range& e) {
63409       {
63410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (std::exception& e) {
63413       {
63414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63419       };
63420     }
63421   }
63422   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63423   return jresult;
63424 }
63425
63426
63427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63428   void * jresult ;
63429   Dali::Toolkit::Control *result = 0 ;
63430
63431   {
63432     try {
63433       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63434     } catch (std::out_of_range& e) {
63435       {
63436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (std::exception& e) {
63439       {
63440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (...) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63445       };
63446     }
63447   }
63448   jresult = (void *)result;
63449   return jresult;
63450 }
63451
63452
63453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63454   void * jresult ;
63455   Dali::Toolkit::Control *arg1 = 0 ;
63456   Dali::Toolkit::Control *result = 0 ;
63457
63458   arg1 = (Dali::Toolkit::Control *)jarg1;
63459   if (!arg1) {
63460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63461     return 0;
63462   }
63463   {
63464     try {
63465       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63466     } catch (std::out_of_range& e) {
63467       {
63468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63469       };
63470     } catch (std::exception& e) {
63471       {
63472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63473       };
63474     } catch (...) {
63475       {
63476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63477       };
63478     }
63479   }
63480   jresult = (void *)result;
63481   return jresult;
63482 }
63483
63484
63485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63486   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63487
63488   arg1 = (Dali::Toolkit::Control *)jarg1;
63489   {
63490     try {
63491       delete arg1;
63492     } catch (std::out_of_range& e) {
63493       {
63494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63495       };
63496     } catch (std::exception& e) {
63497       {
63498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63499       };
63500     } catch (...) {
63501       {
63502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63503       };
63504     }
63505   }
63506 }
63507
63508
63509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63510   void * jresult ;
63511   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63512   Dali::Toolkit::Control *arg2 = 0 ;
63513   Dali::Toolkit::Control *result = 0 ;
63514
63515   arg1 = (Dali::Toolkit::Control *)jarg1;
63516   arg2 = (Dali::Toolkit::Control *)jarg2;
63517   if (!arg2) {
63518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63519     return 0;
63520   }
63521   {
63522     try {
63523       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63524     } catch (std::out_of_range& e) {
63525       {
63526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63527       };
63528     } catch (std::exception& e) {
63529       {
63530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63531       };
63532     } catch (...) {
63533       {
63534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63535       };
63536     }
63537   }
63538   jresult = (void *)result;
63539   return jresult;
63540 }
63541
63542
63543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63544   void * jresult ;
63545   Dali::BaseHandle arg1 ;
63546   Dali::BaseHandle *argp1 ;
63547   Dali::Toolkit::Control result;
63548
63549   argp1 = (Dali::BaseHandle *)jarg1;
63550   if (!argp1) {
63551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63552     return 0;
63553   }
63554   arg1 = *argp1;
63555   {
63556     try {
63557       result = Dali::Toolkit::Control::DownCast(arg1);
63558     } catch (std::out_of_range& e) {
63559       {
63560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63561       };
63562     } catch (std::exception& e) {
63563       {
63564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63565       };
63566     } catch (...) {
63567       {
63568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63569       };
63570     }
63571   }
63572   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63573   return jresult;
63574 }
63575
63576
63577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63578   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63579
63580   arg1 = (Dali::Toolkit::Control *)jarg1;
63581   {
63582     try {
63583       (arg1)->SetKeyInputFocus();
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63591       };
63592     } catch (...) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63595       };
63596     }
63597   }
63598 }
63599
63600
63601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63602   unsigned int jresult ;
63603   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63604   bool result;
63605
63606   arg1 = (Dali::Toolkit::Control *)jarg1;
63607   {
63608     try {
63609       result = (bool)(arg1)->HasKeyInputFocus();
63610     } catch (std::out_of_range& e) {
63611       {
63612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63613       };
63614     } catch (std::exception& e) {
63615       {
63616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63621       };
63622     }
63623   }
63624   jresult = result;
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63630   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63631
63632   arg1 = (Dali::Toolkit::Control *)jarg1;
63633   {
63634     try {
63635       (arg1)->ClearKeyInputFocus();
63636     } catch (std::out_of_range& e) {
63637       {
63638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63639       };
63640     } catch (std::exception& e) {
63641       {
63642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63643       };
63644     } catch (...) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63647       };
63648     }
63649   }
63650 }
63651
63652
63653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63654   void * jresult ;
63655   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63656   Dali::PinchGestureDetector result;
63657
63658   arg1 = (Dali::Toolkit::Control *)jarg1;
63659   {
63660     try {
63661       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63662     } catch (std::out_of_range& e) {
63663       {
63664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63665       };
63666     } catch (std::exception& e) {
63667       {
63668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63669       };
63670     } catch (...) {
63671       {
63672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63673       };
63674     }
63675   }
63676   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63677   return jresult;
63678 }
63679
63680
63681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63682   void * jresult ;
63683   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63684   Dali::PanGestureDetector result;
63685
63686   arg1 = (Dali::Toolkit::Control *)jarg1;
63687   {
63688     try {
63689       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63690     } catch (std::out_of_range& e) {
63691       {
63692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63693       };
63694     } catch (std::exception& e) {
63695       {
63696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63697       };
63698     } catch (...) {
63699       {
63700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63701       };
63702     }
63703   }
63704   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63705   return jresult;
63706 }
63707
63708
63709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63710   void * jresult ;
63711   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63712   Dali::TapGestureDetector result;
63713
63714   arg1 = (Dali::Toolkit::Control *)jarg1;
63715   {
63716     try {
63717       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63718     } catch (std::out_of_range& e) {
63719       {
63720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63721       };
63722     } catch (std::exception& e) {
63723       {
63724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63725       };
63726     } catch (...) {
63727       {
63728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63729       };
63730     }
63731   }
63732   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63733   return jresult;
63734 }
63735
63736
63737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63738   void * jresult ;
63739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63740   Dali::LongPressGestureDetector result;
63741
63742   arg1 = (Dali::Toolkit::Control *)jarg1;
63743   {
63744     try {
63745       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63746     } catch (std::out_of_range& e) {
63747       {
63748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63749       };
63750     } catch (std::exception& e) {
63751       {
63752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63753       };
63754     } catch (...) {
63755       {
63756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63757       };
63758     }
63759   }
63760   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63761   return jresult;
63762 }
63763
63764
63765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63766   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63767   std::string *arg2 = 0 ;
63768
63769   arg1 = (Dali::Toolkit::Control *)jarg1;
63770   if (!jarg2) {
63771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63772     return ;
63773   }
63774   std::string arg2_str(jarg2);
63775   arg2 = &arg2_str;
63776   {
63777     try {
63778       (arg1)->SetStyleName((std::string const &)*arg2);
63779     } catch (std::out_of_range& e) {
63780       {
63781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63782       };
63783     } catch (std::exception& e) {
63784       {
63785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63786       };
63787     } catch (...) {
63788       {
63789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63790       };
63791     }
63792   }
63793
63794   //argout typemap for const std::string&
63795
63796 }
63797
63798
63799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63800   char * jresult ;
63801   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63802   std::string *result = 0 ;
63803
63804   arg1 = (Dali::Toolkit::Control *)jarg1;
63805   {
63806     try {
63807       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63808     } catch (std::out_of_range& e) {
63809       {
63810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63811       };
63812     } catch (std::exception& e) {
63813       {
63814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63815       };
63816     } catch (...) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63819       };
63820     }
63821   }
63822   jresult = SWIG_csharp_string_callback(result->c_str());
63823   return jresult;
63824 }
63825
63826
63827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63828   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63829   Dali::Vector4 *arg2 = 0 ;
63830
63831   arg1 = (Dali::Toolkit::Control *)jarg1;
63832   arg2 = (Dali::Vector4 *)jarg2;
63833   if (!arg2) {
63834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63835     return ;
63836   }
63837   {
63838     try {
63839       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63840     } catch (std::out_of_range& e) {
63841       {
63842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63843       };
63844     } catch (std::exception& e) {
63845       {
63846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63847       };
63848     } catch (...) {
63849       {
63850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63851       };
63852     }
63853   }
63854 }
63855
63856
63857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63858   void * jresult ;
63859   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63860   Dali::Vector4 result;
63861
63862   arg1 = (Dali::Toolkit::Control *)jarg1;
63863   {
63864     try {
63865       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63866     } catch (std::out_of_range& e) {
63867       {
63868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63869       };
63870     } catch (std::exception& e) {
63871       {
63872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63873       };
63874     } catch (...) {
63875       {
63876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63877       };
63878     }
63879   }
63880   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63881   return jresult;
63882 }
63883
63884
63885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63886   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63887   Dali::Image arg2 ;
63888   Dali::Image *argp2 ;
63889
63890   arg1 = (Dali::Toolkit::Control *)jarg1;
63891   argp2 = (Dali::Image *)jarg2;
63892   if (!argp2) {
63893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63894     return ;
63895   }
63896   arg2 = *argp2;
63897   {
63898     try {
63899       (arg1)->SetBackgroundImage(arg2);
63900     } catch (std::out_of_range& e) {
63901       {
63902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63903       };
63904     } catch (std::exception& e) {
63905       {
63906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63907       };
63908     } catch (...) {
63909       {
63910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63911       };
63912     }
63913   }
63914 }
63915
63916
63917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63918   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63919
63920   arg1 = (Dali::Toolkit::Control *)jarg1;
63921   {
63922     try {
63923       (arg1)->ClearBackground();
63924     } catch (std::out_of_range& e) {
63925       {
63926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63927       };
63928     } catch (std::exception& e) {
63929       {
63930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63931       };
63932     } catch (...) {
63933       {
63934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63935       };
63936     }
63937   }
63938 }
63939
63940
63941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63942   void * jresult ;
63943   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63944   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63945
63946   arg1 = (Dali::Toolkit::Control *)jarg1;
63947   {
63948     try {
63949       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63950     } catch (std::out_of_range& e) {
63951       {
63952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63953       };
63954     } catch (std::exception& e) {
63955       {
63956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63957       };
63958     } catch (...) {
63959       {
63960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63961       };
63962     }
63963   }
63964   jresult = (void *)result;
63965   return jresult;
63966 }
63967
63968
63969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63970   void * jresult ;
63971   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63972   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63973
63974   arg1 = (Dali::Toolkit::Control *)jarg1;
63975   {
63976     try {
63977       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63978     } catch (std::out_of_range& e) {
63979       {
63980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63981       };
63982     } catch (std::exception& e) {
63983       {
63984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63985       };
63986     } catch (...) {
63987       {
63988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63989       };
63990     }
63991   }
63992   jresult = (void *)result;
63993   return jresult;
63994 }
63995
63996
63997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63998   void * jresult ;
63999   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64000   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64001
64002   arg1 = (Dali::Toolkit::Control *)jarg1;
64003   {
64004     try {
64005       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64006     } catch (std::out_of_range& e) {
64007       {
64008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64009       };
64010     } catch (std::exception& e) {
64011       {
64012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64013       };
64014     } catch (...) {
64015       {
64016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64017       };
64018     }
64019   }
64020   jresult = (void *)result;
64021   return jresult;
64022 }
64023
64024
64025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64026   void * jresult ;
64027   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64028   Dali::Toolkit::Control *result = 0 ;
64029
64030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64031   if (!arg1) {
64032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64033     return 0;
64034   }
64035   {
64036     try {
64037       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64038     } catch (std::out_of_range& e) {
64039       {
64040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64041       };
64042     } catch (std::exception& e) {
64043       {
64044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64045       };
64046     } catch (...) {
64047       {
64048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64049       };
64050     }
64051   }
64052   jresult = (void *)result;
64053   return jresult;
64054 }
64055
64056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64057   void * jresult ;
64058   Dali::Toolkit::Control *arg1 = 0 ;
64059   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64060
64061   arg1 = (Dali::Toolkit::Control *)jarg1;
64062   if (!arg1) {
64063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64064     return 0;
64065   }
64066   {
64067     try {
64068       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
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 (...) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64080       };
64081     }
64082   }
64083   jresult = (void *)result;
64084   return jresult;
64085 }
64086
64087
64088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64089   unsigned int jresult ;
64090   Dali::Toolkit::Control *arg1 = 0 ;
64091   bool result;
64092
64093   arg1 = (Dali::Toolkit::Control *)jarg1;
64094   if (!arg1) {
64095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64096     return 0;
64097   }
64098   {
64099     try {
64100       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64101     } catch (std::out_of_range& e) {
64102       {
64103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64104       };
64105     } catch (std::exception& e) {
64106       {
64107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64108       };
64109     } catch (...) {
64110       {
64111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64112       };
64113     }
64114   }
64115   jresult = result;
64116   return jresult;
64117 }
64118
64119
64120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64121   void * jresult ;
64122   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64123
64124   {
64125     try {
64126       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64127     } catch (std::out_of_range& e) {
64128       {
64129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (std::exception& e) {
64132       {
64133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141   jresult = (void *)result;
64142   return jresult;
64143 }
64144
64145
64146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64147   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64148
64149   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64150   {
64151     try {
64152       delete arg1;
64153     } catch (std::out_of_range& e) {
64154       {
64155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64156       };
64157     } catch (std::exception& e) {
64158       {
64159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64160       };
64161     } catch (...) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64164       };
64165     }
64166   }
64167 }
64168
64169
64170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64171   void * jresult ;
64172   Dali::Toolkit::KeyInputFocusManager result;
64173
64174   {
64175     try {
64176       result = Dali::Toolkit::KeyInputFocusManager::Get();
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64184       };
64185     } catch (...) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64188       };
64189     }
64190   }
64191   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64192   return jresult;
64193 }
64194
64195
64196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64197   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64198   Dali::Toolkit::Control arg2 ;
64199   Dali::Toolkit::Control *argp2 ;
64200
64201   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64202   argp2 = (Dali::Toolkit::Control *)jarg2;
64203   if (!argp2) {
64204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64205     return ;
64206   }
64207   arg2 = *argp2;
64208   {
64209     try {
64210       (arg1)->SetFocus(arg2);
64211     } catch (std::out_of_range& e) {
64212       {
64213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64214       };
64215     } catch (std::exception& e) {
64216       {
64217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64218       };
64219     } catch (...) {
64220       {
64221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64222       };
64223     }
64224   }
64225 }
64226
64227
64228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64229   void * jresult ;
64230   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64231   Dali::Toolkit::Control result;
64232
64233   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64234   {
64235     try {
64236       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64237     } catch (std::out_of_range& e) {
64238       {
64239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64240       };
64241     } catch (std::exception& e) {
64242       {
64243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64244       };
64245     } catch (...) {
64246       {
64247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64248       };
64249     }
64250   }
64251   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64252   return jresult;
64253 }
64254
64255
64256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64257   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64258   Dali::Toolkit::Control arg2 ;
64259   Dali::Toolkit::Control *argp2 ;
64260
64261   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64262   argp2 = (Dali::Toolkit::Control *)jarg2;
64263   if (!argp2) {
64264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64265     return ;
64266   }
64267   arg2 = *argp2;
64268   {
64269     try {
64270       (arg1)->RemoveFocus(arg2);
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 (...) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64282       };
64283     }
64284   }
64285 }
64286
64287
64288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64289   void * jresult ;
64290   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64291   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64292
64293   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64294   {
64295     try {
64296       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64297     } catch (std::out_of_range& e) {
64298       {
64299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64300       };
64301     } catch (std::exception& e) {
64302       {
64303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64304       };
64305     } catch (...) {
64306       {
64307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64308       };
64309     }
64310   }
64311   jresult = (void *)result;
64312   return jresult;
64313 }
64314
64315
64316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64317   void * jresult ;
64318   Dali::Toolkit::Alignment::Padding *result = 0 ;
64319
64320   {
64321     try {
64322       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64323     } catch (std::out_of_range& e) {
64324       {
64325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (std::exception& e) {
64328       {
64329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64330       };
64331     } catch (...) {
64332       {
64333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64334       };
64335     }
64336   }
64337   jresult = (void *)result;
64338   return jresult;
64339 }
64340
64341
64342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64343   void * jresult ;
64344   float arg1 ;
64345   float arg2 ;
64346   float arg3 ;
64347   float arg4 ;
64348   Dali::Toolkit::Alignment::Padding *result = 0 ;
64349
64350   arg1 = (float)jarg1;
64351   arg2 = (float)jarg2;
64352   arg3 = (float)jarg3;
64353   arg4 = (float)jarg4;
64354   {
64355     try {
64356       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64357     } catch (std::out_of_range& e) {
64358       {
64359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64360       };
64361     } catch (std::exception& e) {
64362       {
64363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64364       };
64365     } catch (...) {
64366       {
64367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64368       };
64369     }
64370   }
64371   jresult = (void *)result;
64372   return jresult;
64373 }
64374
64375
64376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64377   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64378   float arg2 ;
64379
64380   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64381   arg2 = (float)jarg2;
64382   if (arg1) (arg1)->left = arg2;
64383 }
64384
64385
64386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64387   float jresult ;
64388   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64389   float result;
64390
64391   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64392   result = (float) ((arg1)->left);
64393   jresult = result;
64394   return jresult;
64395 }
64396
64397
64398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64399   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64400   float arg2 ;
64401
64402   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64403   arg2 = (float)jarg2;
64404   if (arg1) (arg1)->right = arg2;
64405 }
64406
64407
64408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64409   float jresult ;
64410   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64411   float result;
64412
64413   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64414   result = (float) ((arg1)->right);
64415   jresult = result;
64416   return jresult;
64417 }
64418
64419
64420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64421   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64422   float arg2 ;
64423
64424   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64425   arg2 = (float)jarg2;
64426   if (arg1) (arg1)->top = arg2;
64427 }
64428
64429
64430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64431   float jresult ;
64432   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64433   float result;
64434
64435   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64436   result = (float) ((arg1)->top);
64437   jresult = result;
64438   return jresult;
64439 }
64440
64441
64442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64443   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64444   float arg2 ;
64445
64446   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64447   arg2 = (float)jarg2;
64448   if (arg1) (arg1)->bottom = arg2;
64449 }
64450
64451
64452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64453   float jresult ;
64454   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64455   float result;
64456
64457   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64458   result = (float) ((arg1)->bottom);
64459   jresult = result;
64460   return jresult;
64461 }
64462
64463
64464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64465   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64466
64467   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64468   {
64469     try {
64470       delete arg1;
64471     } catch (std::out_of_range& e) {
64472       {
64473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64474       };
64475     } catch (std::exception& e) {
64476       {
64477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64478       };
64479     } catch (...) {
64480       {
64481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64482       };
64483     }
64484   }
64485 }
64486
64487
64488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64489   void * jresult ;
64490   Dali::Toolkit::Alignment *result = 0 ;
64491
64492   {
64493     try {
64494       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64495     } catch (std::out_of_range& e) {
64496       {
64497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64498       };
64499     } catch (std::exception& e) {
64500       {
64501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64502       };
64503     } catch (...) {
64504       {
64505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64506       };
64507     }
64508   }
64509   jresult = (void *)result;
64510   return jresult;
64511 }
64512
64513
64514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64515   void * jresult ;
64516   Dali::Toolkit::Alignment::Type arg1 ;
64517   Dali::Toolkit::Alignment::Type arg2 ;
64518   Dali::Toolkit::Alignment result;
64519
64520   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64521   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64522   {
64523     try {
64524       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64525     } catch (std::out_of_range& e) {
64526       {
64527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64528       };
64529     } catch (std::exception& e) {
64530       {
64531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64532       };
64533     } catch (...) {
64534       {
64535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64536       };
64537     }
64538   }
64539   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64540   return jresult;
64541 }
64542
64543
64544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64545   void * jresult ;
64546   Dali::Toolkit::Alignment::Type arg1 ;
64547   Dali::Toolkit::Alignment result;
64548
64549   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64550   {
64551     try {
64552       result = Dali::Toolkit::Alignment::New(arg1);
64553     } catch (std::out_of_range& e) {
64554       {
64555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64556       };
64557     } catch (std::exception& e) {
64558       {
64559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64560       };
64561     } catch (...) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64564       };
64565     }
64566   }
64567   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64568   return jresult;
64569 }
64570
64571
64572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64573   void * jresult ;
64574   Dali::Toolkit::Alignment result;
64575
64576   {
64577     try {
64578       result = Dali::Toolkit::Alignment::New();
64579     } catch (std::out_of_range& e) {
64580       {
64581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64582       };
64583     } catch (std::exception& e) {
64584       {
64585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64586       };
64587     } catch (...) {
64588       {
64589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64590       };
64591     }
64592   }
64593   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64594   return jresult;
64595 }
64596
64597
64598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64599   void * jresult ;
64600   Dali::Toolkit::Alignment *arg1 = 0 ;
64601   Dali::Toolkit::Alignment *result = 0 ;
64602
64603   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64604   if (!arg1) {
64605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64606     return 0;
64607   }
64608   {
64609     try {
64610       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (...) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64622       };
64623     }
64624   }
64625   jresult = (void *)result;
64626   return jresult;
64627 }
64628
64629
64630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64631   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64632
64633   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64634   {
64635     try {
64636       delete arg1;
64637     } catch (std::out_of_range& e) {
64638       {
64639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64640       };
64641     } catch (std::exception& e) {
64642       {
64643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64644       };
64645     } catch (...) {
64646       {
64647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64648       };
64649     }
64650   }
64651 }
64652
64653
64654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64655   void * jresult ;
64656   Dali::BaseHandle arg1 ;
64657   Dali::BaseHandle *argp1 ;
64658   Dali::Toolkit::Alignment result;
64659
64660   argp1 = (Dali::BaseHandle *)jarg1;
64661   if (!argp1) {
64662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64663     return 0;
64664   }
64665   arg1 = *argp1;
64666   {
64667     try {
64668       result = Dali::Toolkit::Alignment::DownCast(arg1);
64669     } catch (std::out_of_range& e) {
64670       {
64671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64672       };
64673     } catch (std::exception& e) {
64674       {
64675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64676       };
64677     } catch (...) {
64678       {
64679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64680       };
64681     }
64682   }
64683   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64684   return jresult;
64685 }
64686
64687
64688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64689   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64690   Dali::Toolkit::Alignment::Type arg2 ;
64691
64692   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64693   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64694   {
64695     try {
64696       (arg1)->SetAlignmentType(arg2);
64697     } catch (std::out_of_range& e) {
64698       {
64699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64700       };
64701     } catch (std::exception& e) {
64702       {
64703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64704       };
64705     } catch (...) {
64706       {
64707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64708       };
64709     }
64710   }
64711 }
64712
64713
64714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64715   int jresult ;
64716   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64717   Dali::Toolkit::Alignment::Type result;
64718
64719   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64720   {
64721     try {
64722       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64723     } catch (std::out_of_range& e) {
64724       {
64725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64726       };
64727     } catch (std::exception& e) {
64728       {
64729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64730       };
64731     } catch (...) {
64732       {
64733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64734       };
64735     }
64736   }
64737   jresult = (int)result;
64738   return jresult;
64739 }
64740
64741
64742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64743   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64744   Dali::Toolkit::Alignment::Scaling arg2 ;
64745
64746   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64747   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64748   {
64749     try {
64750       (arg1)->SetScaling(arg2);
64751     } catch (std::out_of_range& e) {
64752       {
64753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64754       };
64755     } catch (std::exception& e) {
64756       {
64757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64758       };
64759     } catch (...) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64762       };
64763     }
64764   }
64765 }
64766
64767
64768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64769   int jresult ;
64770   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64771   Dali::Toolkit::Alignment::Scaling result;
64772
64773   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64774   {
64775     try {
64776       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64777     } catch (std::out_of_range& e) {
64778       {
64779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64780       };
64781     } catch (std::exception& e) {
64782       {
64783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64784       };
64785     } catch (...) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64788       };
64789     }
64790   }
64791   jresult = (int)result;
64792   return jresult;
64793 }
64794
64795
64796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64797   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64798   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64799
64800   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64801   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64802   if (!arg2) {
64803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64804     return ;
64805   }
64806   {
64807     try {
64808       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (...) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64820       };
64821     }
64822   }
64823 }
64824
64825
64826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64827   void * jresult ;
64828   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64829   Dali::Toolkit::Alignment::Padding *result = 0 ;
64830
64831   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64832   {
64833     try {
64834       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64835     } catch (std::out_of_range& e) {
64836       {
64837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64838       };
64839     } catch (std::exception& e) {
64840       {
64841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64842       };
64843     } catch (...) {
64844       {
64845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64846       };
64847     }
64848   }
64849   jresult = (void *)result;
64850   return jresult;
64851 }
64852
64853
64854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64855   void * jresult ;
64856   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64857   Dali::Toolkit::Alignment *arg2 = 0 ;
64858   Dali::Toolkit::Alignment *result = 0 ;
64859
64860   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64861   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64862   if (!arg2) {
64863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64864     return 0;
64865   }
64866   {
64867     try {
64868       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64869     } catch (std::out_of_range& e) {
64870       {
64871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (std::exception& e) {
64874       {
64875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64876       };
64877     } catch (...) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64880       };
64881     }
64882   }
64883   jresult = (void *)result;
64884   return jresult;
64885 }
64886
64887
64888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64889   int jresult ;
64890   int result;
64891
64892   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64893   jresult = (int)result;
64894   return jresult;
64895 }
64896
64897
64898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64899   int jresult ;
64900   int result;
64901
64902   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64903   jresult = (int)result;
64904   return jresult;
64905 }
64906
64907
64908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64909   int jresult ;
64910   int result;
64911
64912   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64913   jresult = (int)result;
64914   return jresult;
64915 }
64916
64917
64918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64919   int jresult ;
64920   int result;
64921
64922   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64923   jresult = (int)result;
64924   return jresult;
64925 }
64926
64927
64928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64929   int jresult ;
64930   int result;
64931
64932   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64933   jresult = (int)result;
64934   return jresult;
64935 }
64936
64937
64938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64939   int jresult ;
64940   int result;
64941
64942   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64943   jresult = (int)result;
64944   return jresult;
64945 }
64946
64947
64948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64949   int jresult ;
64950   int result;
64951
64952   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64953   jresult = (int)result;
64954   return jresult;
64955 }
64956
64957
64958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64959   int jresult ;
64960   int result;
64961
64962   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64963   jresult = (int)result;
64964   return jresult;
64965 }
64966
64967
64968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64969   int jresult ;
64970   int result;
64971
64972   result = (int)Dali::Toolkit::Button::Property::LABEL;
64973   jresult = (int)result;
64974   return jresult;
64975 }
64976
64977
64978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64979   int jresult ;
64980   int result;
64981
64982   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64983   jresult = (int)result;
64984   return jresult;
64985 }
64986
64987
64988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64989   void * jresult ;
64990   Dali::Toolkit::Button::Property *result = 0 ;
64991
64992   {
64993     try {
64994       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64995     } catch (std::out_of_range& e) {
64996       {
64997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64998       };
64999     } catch (std::exception& e) {
65000       {
65001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65002       };
65003     } catch (...) {
65004       {
65005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65006       };
65007     }
65008   }
65009   jresult = (void *)result;
65010   return jresult;
65011 }
65012
65013
65014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65015   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65016
65017   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65018   {
65019     try {
65020       delete arg1;
65021     } catch (std::out_of_range& e) {
65022       {
65023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65024       };
65025     } catch (std::exception& e) {
65026       {
65027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65028       };
65029     } catch (...) {
65030       {
65031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65032       };
65033     }
65034   }
65035 }
65036
65037
65038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65039   void * jresult ;
65040   Dali::Toolkit::Button *result = 0 ;
65041
65042   {
65043     try {
65044       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (...) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65056       };
65057     }
65058   }
65059   jresult = (void *)result;
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65065   void * jresult ;
65066   Dali::Toolkit::Button *arg1 = 0 ;
65067   Dali::Toolkit::Button *result = 0 ;
65068
65069   arg1 = (Dali::Toolkit::Button *)jarg1;
65070   if (!arg1) {
65071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65072     return 0;
65073   }
65074   {
65075     try {
65076       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65077     } catch (std::out_of_range& e) {
65078       {
65079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65080       };
65081     } catch (std::exception& e) {
65082       {
65083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (...) {
65086       {
65087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65088       };
65089     }
65090   }
65091   jresult = (void *)result;
65092   return jresult;
65093 }
65094
65095
65096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65097   void * jresult ;
65098   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65099   Dali::Toolkit::Button *arg2 = 0 ;
65100   Dali::Toolkit::Button *result = 0 ;
65101
65102   arg1 = (Dali::Toolkit::Button *)jarg1;
65103   arg2 = (Dali::Toolkit::Button *)jarg2;
65104   if (!arg2) {
65105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65106     return 0;
65107   }
65108   {
65109     try {
65110       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65111     } catch (std::out_of_range& e) {
65112       {
65113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65114       };
65115     } catch (std::exception& e) {
65116       {
65117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65118       };
65119     } catch (...) {
65120       {
65121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65122       };
65123     }
65124   }
65125   jresult = (void *)result;
65126   return jresult;
65127 }
65128
65129
65130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65131   void * jresult ;
65132   Dali::BaseHandle arg1 ;
65133   Dali::BaseHandle *argp1 ;
65134   Dali::Toolkit::Button result;
65135
65136   argp1 = (Dali::BaseHandle *)jarg1;
65137   if (!argp1) {
65138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65139     return 0;
65140   }
65141   arg1 = *argp1;
65142   {
65143     try {
65144       result = Dali::Toolkit::Button::DownCast(arg1);
65145     } catch (std::out_of_range& e) {
65146       {
65147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65148       };
65149     } catch (std::exception& e) {
65150       {
65151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65152       };
65153     } catch (...) {
65154       {
65155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65156       };
65157     }
65158   }
65159   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65160   return jresult;
65161 }
65162
65163
65164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65165   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65166
65167   arg1 = (Dali::Toolkit::Button *)jarg1;
65168   {
65169     try {
65170       delete arg1;
65171     } catch (std::out_of_range& e) {
65172       {
65173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65174       };
65175     } catch (std::exception& e) {
65176       {
65177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65178       };
65179     } catch (...) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65182       };
65183     }
65184   }
65185 }
65186
65187
65188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65189   unsigned int jresult ;
65190   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65191   bool result;
65192
65193   arg1 = (Dali::Toolkit::Button *)jarg1;
65194   {
65195     try {
65196       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65197     } catch (std::out_of_range& e) {
65198       {
65199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65200       };
65201     } catch (std::exception& e) {
65202       {
65203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65204       };
65205     } catch (...) {
65206       {
65207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65208       };
65209     }
65210   }
65211   jresult = result;
65212   return jresult;
65213 }
65214
65215
65216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65217   unsigned int jresult ;
65218   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65219   bool result;
65220
65221   arg1 = (Dali::Toolkit::Button *)jarg1;
65222   {
65223     try {
65224       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65225     } catch (std::out_of_range& e) {
65226       {
65227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (std::exception& e) {
65230       {
65231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (...) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65236       };
65237     }
65238   }
65239   jresult = result;
65240   return jresult;
65241 }
65242
65243
65244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65245   float jresult ;
65246   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65247   float result;
65248
65249   arg1 = (Dali::Toolkit::Button *)jarg1;
65250   {
65251     try {
65252       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65253     } catch (std::out_of_range& e) {
65254       {
65255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (std::exception& e) {
65258       {
65259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65264       };
65265     }
65266   }
65267   jresult = result;
65268   return jresult;
65269 }
65270
65271
65272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65273   float jresult ;
65274   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65275   float result;
65276
65277   arg1 = (Dali::Toolkit::Button *)jarg1;
65278   {
65279     try {
65280       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65281     } catch (std::out_of_range& e) {
65282       {
65283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65284       };
65285     } catch (std::exception& e) {
65286       {
65287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65288       };
65289     } catch (...) {
65290       {
65291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65292       };
65293     }
65294   }
65295   jresult = result;
65296   return jresult;
65297 }
65298
65299
65300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65301   unsigned int jresult ;
65302   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65303   bool result;
65304
65305   arg1 = (Dali::Toolkit::Button *)jarg1;
65306   {
65307     try {
65308       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65309     } catch (std::out_of_range& e) {
65310       {
65311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (std::exception& e) {
65314       {
65315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65316       };
65317     } catch (...) {
65318       {
65319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65320       };
65321     }
65322   }
65323   jresult = result;
65324   return jresult;
65325 }
65326
65327
65328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65329   unsigned int jresult ;
65330   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65331   bool result;
65332
65333   arg1 = (Dali::Toolkit::Button *)jarg1;
65334   {
65335     try {
65336       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65337     } catch (std::out_of_range& e) {
65338       {
65339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65340       };
65341     } catch (std::exception& e) {
65342       {
65343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65344       };
65345     } catch (...) {
65346       {
65347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65348       };
65349     }
65350   }
65351   jresult = result;
65352   return jresult;
65353 }
65354
65355
65356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65357   float jresult ;
65358   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65359   float result;
65360
65361   arg1 = (Dali::Toolkit::Button *)jarg1;
65362   {
65363     try {
65364       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65365     } catch (std::out_of_range& e) {
65366       {
65367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (std::exception& e) {
65370       {
65371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65376       };
65377     }
65378   }
65379   jresult = result;
65380   return jresult;
65381 }
65382
65383
65384 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65385   char * jresult ;
65386   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65387   std::string result;
65388
65389   arg1 = (Dali::Toolkit::Button *)jarg1;
65390   {
65391     try {
65392       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65393     } catch (std::out_of_range& e) {
65394       {
65395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (std::exception& e) {
65398       {
65399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407   jresult = SWIG_csharp_string_callback((&result)->c_str());
65408   return jresult;
65409 }
65410
65411
65412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65413   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65414   Dali::Actor arg2 ;
65415   Dali::Actor *argp2 ;
65416
65417   arg1 = (Dali::Toolkit::Button *)jarg1;
65418   argp2 = (Dali::Actor *)jarg2;
65419   if (!argp2) {
65420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65421     return ;
65422   }
65423   arg2 = *argp2;
65424   {
65425     try {
65426       (arg1)->SetLabel(arg2);
65427     } catch (std::out_of_range& e) {
65428       {
65429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65430       };
65431     } catch (std::exception& e) {
65432       {
65433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (...) {
65436       {
65437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65438       };
65439     }
65440   }
65441 }
65442
65443
65444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65445   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65446   Dali::Image arg2 ;
65447   Dali::Image *argp2 ;
65448
65449   arg1 = (Dali::Toolkit::Button *)jarg1;
65450   argp2 = (Dali::Image *)jarg2;
65451   if (!argp2) {
65452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65453     return ;
65454   }
65455   arg2 = *argp2;
65456   {
65457     try {
65458       (arg1)->SetButtonImage(arg2);
65459     } catch (std::out_of_range& e) {
65460       {
65461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65462       };
65463     } catch (std::exception& e) {
65464       {
65465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65466       };
65467     } catch (...) {
65468       {
65469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65470       };
65471     }
65472   }
65473 }
65474
65475
65476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65477   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65478   Dali::Image arg2 ;
65479   Dali::Image *argp2 ;
65480
65481   arg1 = (Dali::Toolkit::Button *)jarg1;
65482   argp2 = (Dali::Image *)jarg2;
65483   if (!argp2) {
65484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65485     return ;
65486   }
65487   arg2 = *argp2;
65488   {
65489     try {
65490       (arg1)->SetSelectedImage(arg2);
65491     } catch (std::out_of_range& e) {
65492       {
65493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65494       };
65495     } catch (std::exception& e) {
65496       {
65497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65498       };
65499     } catch (...) {
65500       {
65501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65502       };
65503     }
65504   }
65505 }
65506
65507
65508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65509   void * jresult ;
65510   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65511   Dali::Actor result;
65512
65513   arg1 = (Dali::Toolkit::Button *)jarg1;
65514   {
65515     try {
65516       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65517     } catch (std::out_of_range& e) {
65518       {
65519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65520       };
65521     } catch (std::exception& e) {
65522       {
65523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65524       };
65525     } catch (...) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65528       };
65529     }
65530   }
65531   jresult = new Dali::Actor((const Dali::Actor &)result);
65532   return jresult;
65533 }
65534
65535
65536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65537   void * jresult ;
65538   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65539   Dali::Actor result;
65540
65541   arg1 = (Dali::Toolkit::Button *)jarg1;
65542   {
65543     try {
65544       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65545     } catch (std::out_of_range& e) {
65546       {
65547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65548       };
65549     } catch (std::exception& e) {
65550       {
65551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65552       };
65553     } catch (...) {
65554       {
65555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65556       };
65557     }
65558   }
65559   jresult = new Dali::Actor((const Dali::Actor &)result);
65560   return jresult;
65561 }
65562
65563
65564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65565   void * jresult ;
65566   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65567   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65568
65569   arg1 = (Dali::Toolkit::Button *)jarg1;
65570   {
65571     try {
65572       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65573     } catch (std::out_of_range& e) {
65574       {
65575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65576       };
65577     } catch (std::exception& e) {
65578       {
65579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (...) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65584       };
65585     }
65586   }
65587   jresult = (void *)result;
65588   return jresult;
65589 }
65590
65591
65592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65593   void * jresult ;
65594   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65595   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65596
65597   arg1 = (Dali::Toolkit::Button *)jarg1;
65598   {
65599     try {
65600       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65608       };
65609     } catch (...) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65612       };
65613     }
65614   }
65615   jresult = (void *)result;
65616   return jresult;
65617 }
65618
65619
65620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65621   void * jresult ;
65622   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65623   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65624
65625   arg1 = (Dali::Toolkit::Button *)jarg1;
65626   {
65627     try {
65628       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65629     } catch (std::out_of_range& e) {
65630       {
65631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65632       };
65633     } catch (std::exception& e) {
65634       {
65635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65636       };
65637     } catch (...) {
65638       {
65639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65640       };
65641     }
65642   }
65643   jresult = (void *)result;
65644   return jresult;
65645 }
65646
65647
65648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65649   void * jresult ;
65650   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65651   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65652
65653   arg1 = (Dali::Toolkit::Button *)jarg1;
65654   {
65655     try {
65656       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65657     } catch (std::out_of_range& e) {
65658       {
65659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65660       };
65661     } catch (std::exception& e) {
65662       {
65663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65664       };
65665     } catch (...) {
65666       {
65667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65668       };
65669     }
65670   }
65671   jresult = (void *)result;
65672   return jresult;
65673 }
65674
65675
65676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65677   void * jresult ;
65678   Dali::Toolkit::CheckBoxButton *result = 0 ;
65679
65680   {
65681     try {
65682       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65683     } catch (std::out_of_range& e) {
65684       {
65685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65686       };
65687     } catch (std::exception& e) {
65688       {
65689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (...) {
65692       {
65693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65694       };
65695     }
65696   }
65697   jresult = (void *)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65703   void * jresult ;
65704   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65705   Dali::Toolkit::CheckBoxButton *result = 0 ;
65706
65707   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65708   if (!arg1) {
65709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65710     return 0;
65711   }
65712   {
65713     try {
65714       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65715     } catch (std::out_of_range& e) {
65716       {
65717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65718       };
65719     } catch (std::exception& e) {
65720       {
65721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65722       };
65723     } catch (...) {
65724       {
65725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65726       };
65727     }
65728   }
65729   jresult = (void *)result;
65730   return jresult;
65731 }
65732
65733
65734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65735   void * jresult ;
65736   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65737   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65738   Dali::Toolkit::CheckBoxButton *result = 0 ;
65739
65740   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65741   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65742   if (!arg2) {
65743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65744     return 0;
65745   }
65746   {
65747     try {
65748       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65749     } catch (std::out_of_range& e) {
65750       {
65751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65752       };
65753     } catch (std::exception& e) {
65754       {
65755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65756       };
65757     } catch (...) {
65758       {
65759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65760       };
65761     }
65762   }
65763   jresult = (void *)result;
65764   return jresult;
65765 }
65766
65767
65768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65769   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65770
65771   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65772   {
65773     try {
65774       delete arg1;
65775     } catch (std::out_of_range& e) {
65776       {
65777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65778       };
65779     } catch (std::exception& e) {
65780       {
65781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65782       };
65783     } catch (...) {
65784       {
65785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65786       };
65787     }
65788   }
65789 }
65790
65791
65792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65793   void * jresult ;
65794   Dali::Toolkit::CheckBoxButton result;
65795
65796   {
65797     try {
65798       result = Dali::Toolkit::CheckBoxButton::New();
65799     } catch (std::out_of_range& e) {
65800       {
65801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65802       };
65803     } catch (std::exception& e) {
65804       {
65805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65810       };
65811     }
65812   }
65813   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65814   return jresult;
65815 }
65816
65817
65818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65819   void * jresult ;
65820   Dali::BaseHandle arg1 ;
65821   Dali::BaseHandle *argp1 ;
65822   Dali::Toolkit::CheckBoxButton result;
65823
65824   argp1 = (Dali::BaseHandle *)jarg1;
65825   if (!argp1) {
65826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65827     return 0;
65828   }
65829   arg1 = *argp1;
65830   {
65831     try {
65832       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65833     } catch (std::out_of_range& e) {
65834       {
65835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65836       };
65837     } catch (std::exception& e) {
65838       {
65839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65840       };
65841     } catch (...) {
65842       {
65843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65844       };
65845     }
65846   }
65847   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65848   return jresult;
65849 }
65850
65851
65852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65853   int jresult ;
65854   int result;
65855
65856   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65857   jresult = (int)result;
65858   return jresult;
65859 }
65860
65861
65862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65863   int jresult ;
65864   int result;
65865
65866   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65867   jresult = (int)result;
65868   return jresult;
65869 }
65870
65871
65872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65873   int jresult ;
65874   int result;
65875
65876   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65877   jresult = (int)result;
65878   return jresult;
65879 }
65880
65881
65882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65883   int jresult ;
65884   int result;
65885
65886   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65887   jresult = (int)result;
65888   return jresult;
65889 }
65890
65891
65892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65893   int jresult ;
65894   int result;
65895
65896   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65897   jresult = (int)result;
65898   return jresult;
65899 }
65900
65901
65902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65903   void * jresult ;
65904   Dali::Toolkit::PushButton::Property *result = 0 ;
65905
65906   {
65907     try {
65908       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65909     } catch (std::out_of_range& e) {
65910       {
65911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65912       };
65913     } catch (std::exception& e) {
65914       {
65915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65916       };
65917     } catch (...) {
65918       {
65919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65920       };
65921     }
65922   }
65923   jresult = (void *)result;
65924   return jresult;
65925 }
65926
65927
65928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65929   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65930
65931   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65932   {
65933     try {
65934       delete arg1;
65935     } catch (std::out_of_range& e) {
65936       {
65937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65938       };
65939     } catch (std::exception& e) {
65940       {
65941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65942       };
65943     } catch (...) {
65944       {
65945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65946       };
65947     }
65948   }
65949 }
65950
65951
65952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65953   void * jresult ;
65954   Dali::Toolkit::PushButton *result = 0 ;
65955
65956   {
65957     try {
65958       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65959     } catch (std::out_of_range& e) {
65960       {
65961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65962       };
65963     } catch (std::exception& e) {
65964       {
65965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65966       };
65967     } catch (...) {
65968       {
65969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65970       };
65971     }
65972   }
65973   jresult = (void *)result;
65974   return jresult;
65975 }
65976
65977
65978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65979   void * jresult ;
65980   Dali::Toolkit::PushButton *arg1 = 0 ;
65981   Dali::Toolkit::PushButton *result = 0 ;
65982
65983   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65984   if (!arg1) {
65985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65986     return 0;
65987   }
65988   {
65989     try {
65990       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65991     } catch (std::out_of_range& e) {
65992       {
65993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65994       };
65995     } catch (std::exception& e) {
65996       {
65997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65998       };
65999     } catch (...) {
66000       {
66001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66002       };
66003     }
66004   }
66005   jresult = (void *)result;
66006   return jresult;
66007 }
66008
66009
66010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66011   void * jresult ;
66012   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66013   Dali::Toolkit::PushButton *arg2 = 0 ;
66014   Dali::Toolkit::PushButton *result = 0 ;
66015
66016   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66017   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66018   if (!arg2) {
66019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66020     return 0;
66021   }
66022   {
66023     try {
66024       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66025     } catch (std::out_of_range& e) {
66026       {
66027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66028       };
66029     } catch (std::exception& e) {
66030       {
66031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66032       };
66033     } catch (...) {
66034       {
66035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66036       };
66037     }
66038   }
66039   jresult = (void *)result;
66040   return jresult;
66041 }
66042
66043
66044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66045   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66046
66047   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66048   {
66049     try {
66050       delete arg1;
66051     } catch (std::out_of_range& e) {
66052       {
66053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66054       };
66055     } catch (std::exception& e) {
66056       {
66057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66058       };
66059     } catch (...) {
66060       {
66061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66062       };
66063     }
66064   }
66065 }
66066
66067
66068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66069   void * jresult ;
66070   Dali::Toolkit::PushButton result;
66071
66072   {
66073     try {
66074       result = Dali::Toolkit::PushButton::New();
66075     } catch (std::out_of_range& e) {
66076       {
66077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66078       };
66079     } catch (std::exception& e) {
66080       {
66081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (...) {
66084       {
66085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66086       };
66087     }
66088   }
66089   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66090   return jresult;
66091 }
66092
66093
66094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66095   void * jresult ;
66096   Dali::BaseHandle arg1 ;
66097   Dali::BaseHandle *argp1 ;
66098   Dali::Toolkit::PushButton result;
66099
66100   argp1 = (Dali::BaseHandle *)jarg1;
66101   if (!argp1) {
66102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66103     return 0;
66104   }
66105   arg1 = *argp1;
66106   {
66107     try {
66108       result = Dali::Toolkit::PushButton::DownCast(arg1);
66109     } catch (std::out_of_range& e) {
66110       {
66111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66112       };
66113     } catch (std::exception& e) {
66114       {
66115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66116       };
66117     } catch (...) {
66118       {
66119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66120       };
66121     }
66122   }
66123   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66124   return jresult;
66125 }
66126
66127
66128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66129   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66130   Dali::Image arg2 ;
66131   Dali::Image *argp2 ;
66132
66133   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66134   argp2 = (Dali::Image *)jarg2;
66135   if (!argp2) {
66136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66137     return ;
66138   }
66139   arg2 = *argp2;
66140   {
66141     try {
66142       (arg1)->SetButtonImage(arg2);
66143     } catch (std::out_of_range& e) {
66144       {
66145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66146       };
66147     } catch (std::exception& e) {
66148       {
66149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66150       };
66151     } catch (...) {
66152       {
66153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66154       };
66155     }
66156   }
66157 }
66158
66159
66160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66161   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66162   Dali::Actor arg2 ;
66163   Dali::Actor *argp2 ;
66164
66165   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66166   argp2 = (Dali::Actor *)jarg2;
66167   if (!argp2) {
66168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66169     return ;
66170   }
66171   arg2 = *argp2;
66172   {
66173     try {
66174       (arg1)->SetButtonImage(arg2);
66175     } catch (std::out_of_range& e) {
66176       {
66177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66178       };
66179     } catch (std::exception& e) {
66180       {
66181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66182       };
66183     } catch (...) {
66184       {
66185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66186       };
66187     }
66188   }
66189 }
66190
66191
66192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66193   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66194   Dali::Actor arg2 ;
66195   Dali::Actor *argp2 ;
66196
66197   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66198   argp2 = (Dali::Actor *)jarg2;
66199   if (!argp2) {
66200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66201     return ;
66202   }
66203   arg2 = *argp2;
66204   {
66205     try {
66206       (arg1)->SetBackgroundImage(arg2);
66207     } catch (std::out_of_range& e) {
66208       {
66209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66210       };
66211     } catch (std::exception& e) {
66212       {
66213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66214       };
66215     } catch (...) {
66216       {
66217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66218       };
66219     }
66220   }
66221 }
66222
66223
66224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66225   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66226   Dali::Image arg2 ;
66227   Dali::Image *argp2 ;
66228
66229   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66230   argp2 = (Dali::Image *)jarg2;
66231   if (!argp2) {
66232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66233     return ;
66234   }
66235   arg2 = *argp2;
66236   {
66237     try {
66238       (arg1)->SetSelectedImage(arg2);
66239     } catch (std::out_of_range& e) {
66240       {
66241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66242       };
66243     } catch (std::exception& e) {
66244       {
66245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66250       };
66251     }
66252   }
66253 }
66254
66255
66256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66257   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66258   Dali::Actor arg2 ;
66259   Dali::Actor *argp2 ;
66260
66261   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66262   argp2 = (Dali::Actor *)jarg2;
66263   if (!argp2) {
66264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66265     return ;
66266   }
66267   arg2 = *argp2;
66268   {
66269     try {
66270       (arg1)->SetSelectedImage(arg2);
66271     } catch (std::out_of_range& e) {
66272       {
66273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66274       };
66275     } catch (std::exception& e) {
66276       {
66277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66278       };
66279     } catch (...) {
66280       {
66281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66282       };
66283     }
66284   }
66285 }
66286
66287
66288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66289   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66290   Dali::Actor arg2 ;
66291   Dali::Actor *argp2 ;
66292
66293   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66294   argp2 = (Dali::Actor *)jarg2;
66295   if (!argp2) {
66296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66297     return ;
66298   }
66299   arg2 = *argp2;
66300   {
66301     try {
66302       (arg1)->SetSelectedBackgroundImage(arg2);
66303     } catch (std::out_of_range& e) {
66304       {
66305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66306       };
66307     } catch (std::exception& e) {
66308       {
66309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66310       };
66311     } catch (...) {
66312       {
66313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66314       };
66315     }
66316   }
66317 }
66318
66319
66320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66321   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66322   Dali::Actor arg2 ;
66323   Dali::Actor *argp2 ;
66324
66325   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66326   argp2 = (Dali::Actor *)jarg2;
66327   if (!argp2) {
66328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66329     return ;
66330   }
66331   arg2 = *argp2;
66332   {
66333     try {
66334       (arg1)->SetDisabledBackgroundImage(arg2);
66335     } catch (std::out_of_range& e) {
66336       {
66337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66338       };
66339     } catch (std::exception& e) {
66340       {
66341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66346       };
66347     }
66348   }
66349 }
66350
66351
66352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66353   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66354   Dali::Actor arg2 ;
66355   Dali::Actor *argp2 ;
66356
66357   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66358   argp2 = (Dali::Actor *)jarg2;
66359   if (!argp2) {
66360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66361     return ;
66362   }
66363   arg2 = *argp2;
66364   {
66365     try {
66366       (arg1)->SetDisabledImage(arg2);
66367     } catch (std::out_of_range& e) {
66368       {
66369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66370       };
66371     } catch (std::exception& e) {
66372       {
66373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66374       };
66375     } catch (...) {
66376       {
66377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66378       };
66379     }
66380   }
66381 }
66382
66383
66384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66385   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66386   Dali::Actor arg2 ;
66387   Dali::Actor *argp2 ;
66388
66389   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66390   argp2 = (Dali::Actor *)jarg2;
66391   if (!argp2) {
66392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66393     return ;
66394   }
66395   arg2 = *argp2;
66396   {
66397     try {
66398       (arg1)->SetDisabledSelectedImage(arg2);
66399     } catch (std::out_of_range& e) {
66400       {
66401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66402       };
66403     } catch (std::exception& e) {
66404       {
66405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66406       };
66407     } catch (...) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66410       };
66411     }
66412   }
66413 }
66414
66415
66416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66417   void * jresult ;
66418   Dali::Toolkit::RadioButton *result = 0 ;
66419
66420   {
66421     try {
66422       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66423     } catch (std::out_of_range& e) {
66424       {
66425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66426       };
66427     } catch (std::exception& e) {
66428       {
66429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66430       };
66431     } catch (...) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66434       };
66435     }
66436   }
66437   jresult = (void *)result;
66438   return jresult;
66439 }
66440
66441
66442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66443   void * jresult ;
66444   Dali::Toolkit::RadioButton *arg1 = 0 ;
66445   Dali::Toolkit::RadioButton *result = 0 ;
66446
66447   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66448   if (!arg1) {
66449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66450     return 0;
66451   }
66452   {
66453     try {
66454       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66455     } catch (std::out_of_range& e) {
66456       {
66457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66458       };
66459     } catch (std::exception& e) {
66460       {
66461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66462       };
66463     } catch (...) {
66464       {
66465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66466       };
66467     }
66468   }
66469   jresult = (void *)result;
66470   return jresult;
66471 }
66472
66473
66474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66475   void * jresult ;
66476   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66477   Dali::Toolkit::RadioButton *arg2 = 0 ;
66478   Dali::Toolkit::RadioButton *result = 0 ;
66479
66480   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66481   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66482   if (!arg2) {
66483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66484     return 0;
66485   }
66486   {
66487     try {
66488       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66489     } catch (std::out_of_range& e) {
66490       {
66491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66492       };
66493     } catch (std::exception& e) {
66494       {
66495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66496       };
66497     } catch (...) {
66498       {
66499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66500       };
66501     }
66502   }
66503   jresult = (void *)result;
66504   return jresult;
66505 }
66506
66507
66508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66509   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66510
66511   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66512   {
66513     try {
66514       delete arg1;
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66526       };
66527     }
66528   }
66529 }
66530
66531
66532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66533   void * jresult ;
66534   Dali::Toolkit::RadioButton result;
66535
66536   {
66537     try {
66538       result = Dali::Toolkit::RadioButton::New();
66539     } catch (std::out_of_range& e) {
66540       {
66541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66542       };
66543     } catch (std::exception& e) {
66544       {
66545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66546       };
66547     } catch (...) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66550       };
66551     }
66552   }
66553   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66554   return jresult;
66555 }
66556
66557
66558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66559   void * jresult ;
66560   std::string *arg1 = 0 ;
66561   Dali::Toolkit::RadioButton result;
66562
66563   if (!jarg1) {
66564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66565     return 0;
66566   }
66567   std::string arg1_str(jarg1);
66568   arg1 = &arg1_str;
66569   {
66570     try {
66571       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66572     } catch (std::out_of_range& e) {
66573       {
66574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66575       };
66576     } catch (std::exception& e) {
66577       {
66578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66579       };
66580     } catch (...) {
66581       {
66582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66583       };
66584     }
66585   }
66586   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66587
66588   //argout typemap for const std::string&
66589
66590   return jresult;
66591 }
66592
66593
66594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66595   void * jresult ;
66596   Dali::BaseHandle arg1 ;
66597   Dali::BaseHandle *argp1 ;
66598   Dali::Toolkit::RadioButton result;
66599
66600   argp1 = (Dali::BaseHandle *)jarg1;
66601   if (!argp1) {
66602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66603     return 0;
66604   }
66605   arg1 = *argp1;
66606   {
66607     try {
66608       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66609     } catch (std::out_of_range& e) {
66610       {
66611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66612       };
66613     } catch (std::exception& e) {
66614       {
66615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66616       };
66617     } catch (...) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66620       };
66621     }
66622   }
66623   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66624   return jresult;
66625 }
66626
66627
66628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66629   int jresult ;
66630   int result;
66631
66632   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66633   jresult = (int)result;
66634   return jresult;
66635 }
66636
66637
66638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66639   int jresult ;
66640   int result;
66641
66642   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66643   jresult = (int)result;
66644   return jresult;
66645 }
66646
66647
66648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66649   int jresult ;
66650   int result;
66651
66652   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66653   jresult = (int)result;
66654   return jresult;
66655 }
66656
66657
66658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66659   int jresult ;
66660   int result;
66661
66662   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66663   jresult = (int)result;
66664   return jresult;
66665 }
66666
66667
66668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66669   int jresult ;
66670   int result;
66671
66672   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66673   jresult = (int)result;
66674   return jresult;
66675 }
66676
66677
66678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66679   int jresult ;
66680   int result;
66681
66682   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66683   jresult = (int)result;
66684   return jresult;
66685 }
66686
66687
66688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66689   void * jresult ;
66690   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66691
66692   {
66693     try {
66694       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66695     } catch (std::out_of_range& e) {
66696       {
66697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (std::exception& e) {
66700       {
66701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66702       };
66703     } catch (...) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66706       };
66707     }
66708   }
66709   jresult = (void *)result;
66710   return jresult;
66711 }
66712
66713
66714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66715   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66716
66717   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66718   {
66719     try {
66720       delete arg1;
66721     } catch (std::out_of_range& e) {
66722       {
66723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66724       };
66725     } catch (std::exception& e) {
66726       {
66727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (...) {
66730       {
66731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66732       };
66733     }
66734   }
66735 }
66736
66737
66738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66739   int jresult ;
66740   int result;
66741
66742   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66743   jresult = (int)result;
66744   return jresult;
66745 }
66746
66747
66748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66749   int jresult ;
66750   int result;
66751
66752   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66753   jresult = (int)result;
66754   return jresult;
66755 }
66756
66757
66758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66759   int jresult ;
66760   int result;
66761
66762   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66763   jresult = (int)result;
66764   return jresult;
66765 }
66766
66767
66768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66769   void * jresult ;
66770   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66771
66772   {
66773     try {
66774       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66775     } catch (std::out_of_range& e) {
66776       {
66777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66778       };
66779     } catch (std::exception& e) {
66780       {
66781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66782       };
66783     } catch (...) {
66784       {
66785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66786       };
66787     }
66788   }
66789   jresult = (void *)result;
66790   return jresult;
66791 }
66792
66793
66794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66795   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66796
66797   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66798   {
66799     try {
66800       delete arg1;
66801     } catch (std::out_of_range& e) {
66802       {
66803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (std::exception& e) {
66806       {
66807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66808       };
66809     } catch (...) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66812       };
66813     }
66814   }
66815 }
66816
66817
66818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66819   void * jresult ;
66820   Dali::Toolkit::FlexContainer *result = 0 ;
66821
66822   {
66823     try {
66824       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66825     } catch (std::out_of_range& e) {
66826       {
66827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66828       };
66829     } catch (std::exception& e) {
66830       {
66831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66832       };
66833     } catch (...) {
66834       {
66835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66836       };
66837     }
66838   }
66839   jresult = (void *)result;
66840   return jresult;
66841 }
66842
66843
66844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66845   void * jresult ;
66846   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66847   Dali::Toolkit::FlexContainer *result = 0 ;
66848
66849   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66850   if (!arg1) {
66851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66852     return 0;
66853   }
66854   {
66855     try {
66856       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66857     } catch (std::out_of_range& e) {
66858       {
66859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66860       };
66861     } catch (std::exception& e) {
66862       {
66863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66864       };
66865     } catch (...) {
66866       {
66867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66868       };
66869     }
66870   }
66871   jresult = (void *)result;
66872   return jresult;
66873 }
66874
66875
66876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66877   void * jresult ;
66878   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66879   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66880   Dali::Toolkit::FlexContainer *result = 0 ;
66881
66882   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66883   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66884   if (!arg2) {
66885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66886     return 0;
66887   }
66888   {
66889     try {
66890       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66891     } catch (std::out_of_range& e) {
66892       {
66893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66894       };
66895     } catch (std::exception& e) {
66896       {
66897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66898       };
66899     } catch (...) {
66900       {
66901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66902       };
66903     }
66904   }
66905   jresult = (void *)result;
66906   return jresult;
66907 }
66908
66909
66910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66911   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66912
66913   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66914   {
66915     try {
66916       delete arg1;
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66924       };
66925     } catch (...) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66928       };
66929     }
66930   }
66931 }
66932
66933
66934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66935   void * jresult ;
66936   Dali::Toolkit::FlexContainer result;
66937
66938   {
66939     try {
66940       result = Dali::Toolkit::FlexContainer::New();
66941     } catch (std::out_of_range& e) {
66942       {
66943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66944       };
66945     } catch (std::exception& e) {
66946       {
66947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66948       };
66949     } catch (...) {
66950       {
66951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66952       };
66953     }
66954   }
66955   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66956   return jresult;
66957 }
66958
66959
66960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66961   void * jresult ;
66962   Dali::BaseHandle arg1 ;
66963   Dali::BaseHandle *argp1 ;
66964   Dali::Toolkit::FlexContainer result;
66965
66966   argp1 = (Dali::BaseHandle *)jarg1;
66967   if (!argp1) {
66968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66969     return 0;
66970   }
66971   arg1 = *argp1;
66972   {
66973     try {
66974       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66975     } catch (std::out_of_range& e) {
66976       {
66977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66978       };
66979     } catch (std::exception& e) {
66980       {
66981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66982       };
66983     } catch (...) {
66984       {
66985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66986       };
66987     }
66988   }
66989   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66990   return jresult;
66991 }
66992
66993
66994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66995   int jresult ;
66996   int result;
66997
66998   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66999   jresult = (int)result;
67000   return jresult;
67001 }
67002
67003
67004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67005   int jresult ;
67006   int result;
67007
67008   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67009   jresult = (int)result;
67010   return jresult;
67011 }
67012
67013
67014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67015   int jresult ;
67016   int result;
67017
67018   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67019   jresult = (int)result;
67020   return jresult;
67021 }
67022
67023
67024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67025   int jresult ;
67026   int result;
67027
67028   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67029   jresult = (int)result;
67030   return jresult;
67031 }
67032
67033
67034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67035   void * jresult ;
67036   Dali::Toolkit::ImageView::Property *result = 0 ;
67037
67038   {
67039     try {
67040       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67041     } catch (std::out_of_range& e) {
67042       {
67043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (std::exception& e) {
67046       {
67047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67048       };
67049     } catch (...) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67052       };
67053     }
67054   }
67055   jresult = (void *)result;
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67061   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67062
67063   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67064   {
67065     try {
67066       delete arg1;
67067     } catch (std::out_of_range& e) {
67068       {
67069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67070       };
67071     } catch (std::exception& e) {
67072       {
67073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67074       };
67075     } catch (...) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67078       };
67079     }
67080   }
67081 }
67082
67083
67084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67085   void * jresult ;
67086   Dali::Toolkit::ImageView *result = 0 ;
67087
67088   {
67089     try {
67090       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67098       };
67099     } catch (...) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67102       };
67103     }
67104   }
67105   jresult = (void *)result;
67106   return jresult;
67107 }
67108
67109
67110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67111   void * jresult ;
67112   Dali::Toolkit::ImageView result;
67113
67114   {
67115     try {
67116       result = Dali::Toolkit::ImageView::New();
67117     } catch (std::out_of_range& e) {
67118       {
67119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67120       };
67121     } catch (std::exception& e) {
67122       {
67123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67124       };
67125     } catch (...) {
67126       {
67127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67128       };
67129     }
67130   }
67131   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67132   return jresult;
67133 }
67134
67135
67136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67137   void * jresult ;
67138   Dali::Image arg1 ;
67139   Dali::Image *argp1 ;
67140   Dali::Toolkit::ImageView result;
67141
67142   argp1 = (Dali::Image *)jarg1;
67143   if (!argp1) {
67144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67145     return 0;
67146   }
67147   arg1 = *argp1;
67148   {
67149     try {
67150       result = Dali::Toolkit::ImageView::New(arg1);
67151     } catch (std::out_of_range& e) {
67152       {
67153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67154       };
67155     } catch (std::exception& e) {
67156       {
67157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67158       };
67159     } catch (...) {
67160       {
67161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67162       };
67163     }
67164   }
67165   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67166   return jresult;
67167 }
67168
67169
67170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67171   void * jresult ;
67172   std::string *arg1 = 0 ;
67173   Dali::Toolkit::ImageView result;
67174
67175   if (!jarg1) {
67176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67177     return 0;
67178   }
67179   std::string arg1_str(jarg1);
67180   arg1 = &arg1_str;
67181   {
67182     try {
67183       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67184     } catch (std::out_of_range& e) {
67185       {
67186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67187       };
67188     } catch (std::exception& e) {
67189       {
67190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67191       };
67192     } catch (...) {
67193       {
67194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67195       };
67196     }
67197   }
67198   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67199
67200   //argout typemap for const std::string&
67201
67202   return jresult;
67203 }
67204
67205
67206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67207   void * jresult ;
67208   std::string *arg1 = 0 ;
67209   Dali::ImageDimensions arg2 ;
67210   Dali::ImageDimensions *argp2 ;
67211   Dali::Toolkit::ImageView result;
67212
67213   if (!jarg1) {
67214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67215     return 0;
67216   }
67217   std::string arg1_str(jarg1);
67218   arg1 = &arg1_str;
67219   argp2 = (Dali::ImageDimensions *)jarg2;
67220   if (!argp2) {
67221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67222     return 0;
67223   }
67224   arg2 = *argp2;
67225   {
67226     try {
67227       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67228     } catch (std::out_of_range& e) {
67229       {
67230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67231       };
67232     } catch (std::exception& e) {
67233       {
67234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (...) {
67237       {
67238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67239       };
67240     }
67241   }
67242   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67243
67244   //argout typemap for const std::string&
67245
67246   return jresult;
67247 }
67248
67249
67250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67251   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67252
67253   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67254   {
67255     try {
67256       delete arg1;
67257     } catch (std::out_of_range& e) {
67258       {
67259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67260       };
67261     } catch (std::exception& e) {
67262       {
67263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67264       };
67265     } catch (...) {
67266       {
67267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67268       };
67269     }
67270   }
67271 }
67272
67273
67274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67275   void * jresult ;
67276   Dali::Toolkit::ImageView *arg1 = 0 ;
67277   Dali::Toolkit::ImageView *result = 0 ;
67278
67279   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67280   if (!arg1) {
67281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67282     return 0;
67283   }
67284   {
67285     try {
67286       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67287     } catch (std::out_of_range& e) {
67288       {
67289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67290       };
67291     } catch (std::exception& e) {
67292       {
67293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67294       };
67295     } catch (...) {
67296       {
67297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67298       };
67299     }
67300   }
67301   jresult = (void *)result;
67302   return jresult;
67303 }
67304
67305
67306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67307   void * jresult ;
67308   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67309   Dali::Toolkit::ImageView *arg2 = 0 ;
67310   Dali::Toolkit::ImageView *result = 0 ;
67311
67312   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67313   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67314   if (!arg2) {
67315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67316     return 0;
67317   }
67318   {
67319     try {
67320       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67328       };
67329     } catch (...) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67332       };
67333     }
67334   }
67335   jresult = (void *)result;
67336   return jresult;
67337 }
67338
67339
67340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67341   void * jresult ;
67342   Dali::BaseHandle arg1 ;
67343   Dali::BaseHandle *argp1 ;
67344   Dali::Toolkit::ImageView result;
67345
67346   argp1 = (Dali::BaseHandle *)jarg1;
67347   if (!argp1) {
67348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67349     return 0;
67350   }
67351   arg1 = *argp1;
67352   {
67353     try {
67354       result = Dali::Toolkit::ImageView::DownCast(arg1);
67355     } catch (std::out_of_range& e) {
67356       {
67357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67358       };
67359     } catch (std::exception& e) {
67360       {
67361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67362       };
67363     } catch (...) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67366       };
67367     }
67368   }
67369   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67370   return jresult;
67371 }
67372
67373
67374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67375   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67376   Dali::Image arg2 ;
67377   Dali::Image *argp2 ;
67378
67379   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67380   argp2 = (Dali::Image *)jarg2;
67381   if (!argp2) {
67382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67383     return ;
67384   }
67385   arg2 = *argp2;
67386   {
67387     try {
67388       (arg1)->SetImage(arg2);
67389     } catch (std::out_of_range& e) {
67390       {
67391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67392       };
67393     } catch (std::exception& e) {
67394       {
67395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67400       };
67401     }
67402   }
67403 }
67404
67405
67406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67407   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67408   std::string *arg2 = 0 ;
67409
67410   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67411   if (!jarg2) {
67412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67413     return ;
67414   }
67415   std::string arg2_str(jarg2);
67416   arg2 = &arg2_str;
67417   {
67418     try {
67419       (arg1)->SetImage((std::string const &)*arg2);
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67431       };
67432     }
67433   }
67434
67435   //argout typemap for const std::string&
67436
67437 }
67438
67439
67440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67441   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67442   std::string *arg2 = 0 ;
67443   Dali::ImageDimensions arg3 ;
67444   Dali::ImageDimensions *argp3 ;
67445
67446   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67447   if (!jarg2) {
67448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67449     return ;
67450   }
67451   std::string arg2_str(jarg2);
67452   arg2 = &arg2_str;
67453   argp3 = (Dali::ImageDimensions *)jarg3;
67454   if (!argp3) {
67455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67456     return ;
67457   }
67458   arg3 = *argp3;
67459   {
67460     try {
67461       (arg1)->SetImage((std::string const &)*arg2,arg3);
67462     } catch (std::out_of_range& e) {
67463       {
67464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67465       };
67466     } catch (std::exception& e) {
67467       {
67468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67469       };
67470     } catch (...) {
67471       {
67472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67473       };
67474     }
67475   }
67476
67477   //argout typemap for const std::string&
67478
67479 }
67480
67481
67482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67483   void * jresult ;
67484   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67485   Dali::Image result;
67486
67487   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67488   {
67489     try {
67490       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67491     } catch (std::out_of_range& e) {
67492       {
67493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67494       };
67495     } catch (std::exception& e) {
67496       {
67497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (...) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67502       };
67503     }
67504   }
67505   jresult = new Dali::Image((const Dali::Image &)result);
67506   return jresult;
67507 }
67508
67509
67510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67511   int jresult ;
67512   int result;
67513
67514   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67515   jresult = (int)result;
67516   return jresult;
67517 }
67518
67519
67520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67521   int jresult ;
67522   int result;
67523
67524   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67525   jresult = (int)result;
67526   return jresult;
67527 }
67528
67529
67530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67531   int jresult ;
67532   int result;
67533
67534   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67535   jresult = (int)result;
67536   return jresult;
67537 }
67538
67539
67540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67541   int jresult ;
67542   int result;
67543
67544   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67545   jresult = (int)result;
67546   return jresult;
67547 }
67548
67549
67550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67551   int jresult ;
67552   int result;
67553
67554   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67555   jresult = (int)result;
67556   return jresult;
67557 }
67558
67559
67560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67561   int jresult ;
67562   int result;
67563
67564   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67565   jresult = (int)result;
67566   return jresult;
67567 }
67568
67569
67570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67571   int jresult ;
67572   int result;
67573
67574   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67575   jresult = (int)result;
67576   return jresult;
67577 }
67578
67579
67580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67581   int jresult ;
67582   int result;
67583
67584   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67585   jresult = (int)result;
67586   return jresult;
67587 }
67588
67589
67590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67591   void * jresult ;
67592   Dali::Toolkit::Model3dView::Property *result = 0 ;
67593
67594   {
67595     try {
67596       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67597     } catch (std::out_of_range& e) {
67598       {
67599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67600       };
67601     } catch (std::exception& e) {
67602       {
67603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67604       };
67605     } catch (...) {
67606       {
67607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67608       };
67609     }
67610   }
67611   jresult = (void *)result;
67612   return jresult;
67613 }
67614
67615
67616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67617   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67618
67619   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67620   {
67621     try {
67622       delete arg1;
67623     } catch (std::out_of_range& e) {
67624       {
67625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67626       };
67627     } catch (std::exception& e) {
67628       {
67629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67630       };
67631     } catch (...) {
67632       {
67633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67634       };
67635     }
67636   }
67637 }
67638
67639
67640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67641   void * jresult ;
67642   Dali::Toolkit::Model3dView result;
67643
67644   {
67645     try {
67646       result = Dali::Toolkit::Model3dView::New();
67647     } catch (std::out_of_range& e) {
67648       {
67649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67650       };
67651     } catch (std::exception& e) {
67652       {
67653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67654       };
67655     } catch (...) {
67656       {
67657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67658       };
67659     }
67660   }
67661   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67662   return jresult;
67663 }
67664
67665
67666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67667   void * jresult ;
67668   std::string *arg1 = 0 ;
67669   std::string *arg2 = 0 ;
67670   std::string *arg3 = 0 ;
67671   Dali::Toolkit::Model3dView result;
67672
67673   if (!jarg1) {
67674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67675     return 0;
67676   }
67677   std::string arg1_str(jarg1);
67678   arg1 = &arg1_str;
67679   if (!jarg2) {
67680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67681     return 0;
67682   }
67683   std::string arg2_str(jarg2);
67684   arg2 = &arg2_str;
67685   if (!jarg3) {
67686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67687     return 0;
67688   }
67689   std::string arg3_str(jarg3);
67690   arg3 = &arg3_str;
67691   {
67692     try {
67693       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67694     } catch (std::out_of_range& e) {
67695       {
67696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67697       };
67698     } catch (std::exception& e) {
67699       {
67700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67701       };
67702     } catch (...) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67705       };
67706     }
67707   }
67708   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67709
67710   //argout typemap for const std::string&
67711
67712
67713   //argout typemap for const std::string&
67714
67715
67716   //argout typemap for const std::string&
67717
67718   return jresult;
67719 }
67720
67721
67722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67723   void * jresult ;
67724   Dali::Toolkit::Model3dView *result = 0 ;
67725
67726   {
67727     try {
67728       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67729     } catch (std::out_of_range& e) {
67730       {
67731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (std::exception& e) {
67734       {
67735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67740       };
67741     }
67742   }
67743   jresult = (void *)result;
67744   return jresult;
67745 }
67746
67747
67748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67749   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67750
67751   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67752   {
67753     try {
67754       delete arg1;
67755     } catch (std::out_of_range& e) {
67756       {
67757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67758       };
67759     } catch (std::exception& e) {
67760       {
67761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67762       };
67763     } catch (...) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67766       };
67767     }
67768   }
67769 }
67770
67771
67772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67773   void * jresult ;
67774   Dali::Toolkit::Model3dView *arg1 = 0 ;
67775   Dali::Toolkit::Model3dView *result = 0 ;
67776
67777   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67778   if (!arg1) {
67779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67780     return 0;
67781   }
67782   {
67783     try {
67784       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67785     } catch (std::out_of_range& e) {
67786       {
67787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67788       };
67789     } catch (std::exception& e) {
67790       {
67791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67792       };
67793     } catch (...) {
67794       {
67795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67796       };
67797     }
67798   }
67799   jresult = (void *)result;
67800   return jresult;
67801 }
67802
67803
67804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67805   void * jresult ;
67806   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67807   Dali::Toolkit::Model3dView *arg2 = 0 ;
67808   Dali::Toolkit::Model3dView *result = 0 ;
67809
67810   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67811   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67812   if (!arg2) {
67813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67814     return 0;
67815   }
67816   {
67817     try {
67818       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67819     } catch (std::out_of_range& e) {
67820       {
67821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67822       };
67823     } catch (std::exception& e) {
67824       {
67825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67826       };
67827     } catch (...) {
67828       {
67829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67830       };
67831     }
67832   }
67833   jresult = (void *)result;
67834   return jresult;
67835 }
67836
67837
67838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67839   void * jresult ;
67840   Dali::BaseHandle arg1 ;
67841   Dali::BaseHandle *argp1 ;
67842   Dali::Toolkit::Model3dView result;
67843
67844   argp1 = (Dali::BaseHandle *)jarg1;
67845   if (!argp1) {
67846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67847     return 0;
67848   }
67849   arg1 = *argp1;
67850   {
67851     try {
67852       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67853     } catch (std::out_of_range& e) {
67854       {
67855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67856       };
67857     } catch (std::exception& e) {
67858       {
67859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67860       };
67861     } catch (...) {
67862       {
67863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67864       };
67865     }
67866   }
67867   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67868   return jresult;
67869 }
67870
67871
67872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67873   int jresult ;
67874   int result;
67875
67876   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67877   jresult = (int)result;
67878   return jresult;
67879 }
67880
67881
67882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67883   int jresult ;
67884   int result;
67885
67886   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67887   jresult = (int)result;
67888   return jresult;
67889 }
67890
67891
67892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67893   int jresult ;
67894   int result;
67895
67896   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67897   jresult = (int)result;
67898   return jresult;
67899 }
67900
67901
67902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67903   int jresult ;
67904   int result;
67905
67906   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67907   jresult = (int)result;
67908   return jresult;
67909 }
67910
67911
67912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67913   int jresult ;
67914   int result;
67915
67916   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67917   jresult = (int)result;
67918   return jresult;
67919 }
67920
67921
67922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67923   int jresult ;
67924   int result;
67925
67926   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67927   jresult = (int)result;
67928   return jresult;
67929 }
67930
67931
67932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67933   int jresult ;
67934   int result;
67935
67936   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67937   jresult = (int)result;
67938   return jresult;
67939 }
67940
67941
67942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67943   int jresult ;
67944   int result;
67945
67946   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67947   jresult = (int)result;
67948   return jresult;
67949 }
67950
67951
67952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67953   int jresult ;
67954   int result;
67955
67956   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67957   jresult = (int)result;
67958   return jresult;
67959 }
67960
67961
67962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67963   void * jresult ;
67964   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67965
67966   {
67967     try {
67968       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67969     } catch (std::out_of_range& e) {
67970       {
67971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67972       };
67973     } catch (std::exception& e) {
67974       {
67975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67976       };
67977     } catch (...) {
67978       {
67979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67980       };
67981     }
67982   }
67983   jresult = (void *)result;
67984   return jresult;
67985 }
67986
67987
67988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67989   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67990
67991   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67992   {
67993     try {
67994       delete arg1;
67995     } catch (std::out_of_range& e) {
67996       {
67997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67998       };
67999     } catch (std::exception& e) {
68000       {
68001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68002       };
68003     } catch (...) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68006       };
68007     }
68008   }
68009 }
68010
68011
68012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68013   void * jresult ;
68014   Dali::Toolkit::ScrollBar *result = 0 ;
68015
68016   {
68017     try {
68018       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68019     } catch (std::out_of_range& e) {
68020       {
68021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68022       };
68023     } catch (std::exception& e) {
68024       {
68025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68026       };
68027     } catch (...) {
68028       {
68029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68030       };
68031     }
68032   }
68033   jresult = (void *)result;
68034   return jresult;
68035 }
68036
68037
68038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68039   void * jresult ;
68040   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68041   Dali::Toolkit::ScrollBar *result = 0 ;
68042
68043   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68044   if (!arg1) {
68045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68046     return 0;
68047   }
68048   {
68049     try {
68050       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68051     } catch (std::out_of_range& e) {
68052       {
68053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68054       };
68055     } catch (std::exception& e) {
68056       {
68057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68058       };
68059     } catch (...) {
68060       {
68061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68062       };
68063     }
68064   }
68065   jresult = (void *)result;
68066   return jresult;
68067 }
68068
68069
68070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68071   void * jresult ;
68072   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68073   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68074   Dali::Toolkit::ScrollBar *result = 0 ;
68075
68076   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68077   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68078   if (!arg2) {
68079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68080     return 0;
68081   }
68082   {
68083     try {
68084       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68085     } catch (std::out_of_range& e) {
68086       {
68087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68088       };
68089     } catch (std::exception& e) {
68090       {
68091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68092       };
68093     } catch (...) {
68094       {
68095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68096       };
68097     }
68098   }
68099   jresult = (void *)result;
68100   return jresult;
68101 }
68102
68103
68104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68105   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68106
68107   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68108   {
68109     try {
68110       delete arg1;
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68118       };
68119     } catch (...) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68122       };
68123     }
68124   }
68125 }
68126
68127
68128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68129   void * jresult ;
68130   Dali::Toolkit::ScrollBar::Direction arg1 ;
68131   Dali::Toolkit::ScrollBar result;
68132
68133   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68134   {
68135     try {
68136       result = Dali::Toolkit::ScrollBar::New(arg1);
68137     } catch (std::out_of_range& e) {
68138       {
68139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68140       };
68141     } catch (std::exception& e) {
68142       {
68143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68144       };
68145     } catch (...) {
68146       {
68147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68148       };
68149     }
68150   }
68151   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68152   return jresult;
68153 }
68154
68155
68156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68157   void * jresult ;
68158   Dali::Toolkit::ScrollBar result;
68159
68160   {
68161     try {
68162       result = Dali::Toolkit::ScrollBar::New();
68163     } catch (std::out_of_range& e) {
68164       {
68165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68166       };
68167     } catch (std::exception& e) {
68168       {
68169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68170       };
68171     } catch (...) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68174       };
68175     }
68176   }
68177   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68178   return jresult;
68179 }
68180
68181
68182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68183   void * jresult ;
68184   Dali::BaseHandle arg1 ;
68185   Dali::BaseHandle *argp1 ;
68186   Dali::Toolkit::ScrollBar result;
68187
68188   argp1 = (Dali::BaseHandle *)jarg1;
68189   if (!argp1) {
68190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68191     return 0;
68192   }
68193   arg1 = *argp1;
68194   {
68195     try {
68196       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68197     } catch (std::out_of_range& e) {
68198       {
68199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68200       };
68201     } catch (std::exception& e) {
68202       {
68203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68204       };
68205     } catch (...) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68208       };
68209     }
68210   }
68211   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68212   return jresult;
68213 }
68214
68215
68216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68217   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68218   Dali::Handle arg2 ;
68219   Dali::Property::Index arg3 ;
68220   Dali::Property::Index arg4 ;
68221   Dali::Property::Index arg5 ;
68222   Dali::Property::Index arg6 ;
68223   Dali::Handle *argp2 ;
68224
68225   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68226   argp2 = (Dali::Handle *)jarg2;
68227   if (!argp2) {
68228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68229     return ;
68230   }
68231   arg2 = *argp2;
68232   arg3 = (Dali::Property::Index)jarg3;
68233   arg4 = (Dali::Property::Index)jarg4;
68234   arg5 = (Dali::Property::Index)jarg5;
68235   arg6 = (Dali::Property::Index)jarg6;
68236   {
68237     try {
68238       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68239     } catch (std::out_of_range& e) {
68240       {
68241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68242       };
68243     } catch (std::exception& e) {
68244       {
68245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68246       };
68247     } catch (...) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68250       };
68251     }
68252   }
68253 }
68254
68255
68256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68257   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68258   Dali::Actor arg2 ;
68259   Dali::Actor *argp2 ;
68260
68261   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68262   argp2 = (Dali::Actor *)jarg2;
68263   if (!argp2) {
68264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68265     return ;
68266   }
68267   arg2 = *argp2;
68268   {
68269     try {
68270       (arg1)->SetScrollIndicator(arg2);
68271     } catch (std::out_of_range& e) {
68272       {
68273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68274       };
68275     } catch (std::exception& e) {
68276       {
68277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68278       };
68279     } catch (...) {
68280       {
68281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68282       };
68283     }
68284   }
68285 }
68286
68287
68288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68289   void * jresult ;
68290   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68291   Dali::Actor result;
68292
68293   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68294   {
68295     try {
68296       result = (arg1)->GetScrollIndicator();
68297     } catch (std::out_of_range& e) {
68298       {
68299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68300       };
68301     } catch (std::exception& e) {
68302       {
68303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68304       };
68305     } catch (...) {
68306       {
68307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68308       };
68309     }
68310   }
68311   jresult = new Dali::Actor((const Dali::Actor &)result);
68312   return jresult;
68313 }
68314
68315
68316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68317   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68318   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68319
68320   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68321   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68322   if (!arg2) {
68323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68324     return ;
68325   }
68326   {
68327     try {
68328       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68329     } catch (std::out_of_range& e) {
68330       {
68331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68332       };
68333     } catch (std::exception& e) {
68334       {
68335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68336       };
68337     } catch (...) {
68338       {
68339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68340       };
68341     }
68342   }
68343 }
68344
68345
68346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68347   void * jresult ;
68348   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68349   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68350
68351   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68352   {
68353     try {
68354       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68366       };
68367     }
68368   }
68369   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68375   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68376   Dali::Toolkit::ScrollBar::Direction arg2 ;
68377
68378   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68379   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68380   {
68381     try {
68382       (arg1)->SetScrollDirection(arg2);
68383     } catch (std::out_of_range& e) {
68384       {
68385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68386       };
68387     } catch (std::exception& e) {
68388       {
68389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68390       };
68391     } catch (...) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68394       };
68395     }
68396   }
68397 }
68398
68399
68400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68401   int jresult ;
68402   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68403   Dali::Toolkit::ScrollBar::Direction result;
68404
68405   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68406   {
68407     try {
68408       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68409     } catch (std::out_of_range& e) {
68410       {
68411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68412       };
68413     } catch (std::exception& e) {
68414       {
68415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68416       };
68417     } catch (...) {
68418       {
68419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68420       };
68421     }
68422   }
68423   jresult = (int)result;
68424   return jresult;
68425 }
68426
68427
68428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68429   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68430   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68431
68432   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68433   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68434   {
68435     try {
68436       (arg1)->SetIndicatorHeightPolicy(arg2);
68437     } catch (std::out_of_range& e) {
68438       {
68439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68440       };
68441     } catch (std::exception& e) {
68442       {
68443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68444       };
68445     } catch (...) {
68446       {
68447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68448       };
68449     }
68450   }
68451 }
68452
68453
68454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68455   int jresult ;
68456   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68457   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68458
68459   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68460   {
68461     try {
68462       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68463     } catch (std::out_of_range& e) {
68464       {
68465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68466       };
68467     } catch (std::exception& e) {
68468       {
68469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68470       };
68471     } catch (...) {
68472       {
68473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68474       };
68475     }
68476   }
68477   jresult = (int)result;
68478   return jresult;
68479 }
68480
68481
68482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68483   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68484   float arg2 ;
68485
68486   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68487   arg2 = (float)jarg2;
68488   {
68489     try {
68490       (arg1)->SetIndicatorFixedHeight(arg2);
68491     } catch (std::out_of_range& e) {
68492       {
68493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68494       };
68495     } catch (std::exception& e) {
68496       {
68497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68498       };
68499     } catch (...) {
68500       {
68501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68502       };
68503     }
68504   }
68505 }
68506
68507
68508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68509   float jresult ;
68510   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68511   float result;
68512
68513   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68514   {
68515     try {
68516       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68517     } catch (std::out_of_range& e) {
68518       {
68519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68520       };
68521     } catch (std::exception& e) {
68522       {
68523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68524       };
68525     } catch (...) {
68526       {
68527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68528       };
68529     }
68530   }
68531   jresult = result;
68532   return jresult;
68533 }
68534
68535
68536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68537   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68538   float arg2 ;
68539
68540   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68541   arg2 = (float)jarg2;
68542   {
68543     try {
68544       (arg1)->SetIndicatorShowDuration(arg2);
68545     } catch (std::out_of_range& e) {
68546       {
68547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68548       };
68549     } catch (std::exception& e) {
68550       {
68551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68552       };
68553     } catch (...) {
68554       {
68555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68556       };
68557     }
68558   }
68559 }
68560
68561
68562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68563   float jresult ;
68564   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68565   float result;
68566
68567   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68568   {
68569     try {
68570       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68571     } catch (std::out_of_range& e) {
68572       {
68573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68574       };
68575     } catch (std::exception& e) {
68576       {
68577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68578       };
68579     } catch (...) {
68580       {
68581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68582       };
68583     }
68584   }
68585   jresult = result;
68586   return jresult;
68587 }
68588
68589
68590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68591   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68592   float arg2 ;
68593
68594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68595   arg2 = (float)jarg2;
68596   {
68597     try {
68598       (arg1)->SetIndicatorHideDuration(arg2);
68599     } catch (std::out_of_range& e) {
68600       {
68601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68602       };
68603     } catch (std::exception& e) {
68604       {
68605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68606       };
68607     } catch (...) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68610       };
68611     }
68612   }
68613 }
68614
68615
68616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68617   float jresult ;
68618   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68619   float result;
68620
68621   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68622   {
68623     try {
68624       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68632       };
68633     } catch (...) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68636       };
68637     }
68638   }
68639   jresult = result;
68640   return jresult;
68641 }
68642
68643
68644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68645   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68646
68647   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68648   {
68649     try {
68650       (arg1)->ShowIndicator();
68651     } catch (std::out_of_range& e) {
68652       {
68653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68654       };
68655     } catch (std::exception& e) {
68656       {
68657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68658       };
68659     } catch (...) {
68660       {
68661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68662       };
68663     }
68664   }
68665 }
68666
68667
68668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68669   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68670
68671   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68672   {
68673     try {
68674       (arg1)->HideIndicator();
68675     } catch (std::out_of_range& e) {
68676       {
68677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68678       };
68679     } catch (std::exception& e) {
68680       {
68681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68682       };
68683     } catch (...) {
68684       {
68685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68686       };
68687     }
68688   }
68689 }
68690
68691
68692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68693   void * jresult ;
68694   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68695   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68696
68697   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68698   {
68699     try {
68700       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68701     } catch (std::out_of_range& e) {
68702       {
68703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68704       };
68705     } catch (std::exception& e) {
68706       {
68707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68708       };
68709     } catch (...) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68712       };
68713     }
68714   }
68715   jresult = (void *)result;
68716   return jresult;
68717 }
68718
68719
68720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68721   void * jresult ;
68722   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68723   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68724
68725   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68726   {
68727     try {
68728       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68729     } catch (std::out_of_range& e) {
68730       {
68731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68732       };
68733     } catch (std::exception& e) {
68734       {
68735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68736       };
68737     } catch (...) {
68738       {
68739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68740       };
68741     }
68742   }
68743   jresult = (void *)result;
68744   return jresult;
68745 }
68746
68747
68748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68749   int jresult ;
68750   int result;
68751
68752   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68753   jresult = (int)result;
68754   return jresult;
68755 }
68756
68757
68758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68759   int jresult ;
68760   int result;
68761
68762   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68763   jresult = (int)result;
68764   return jresult;
68765 }
68766
68767
68768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68769   int jresult ;
68770   int result;
68771
68772   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68773   jresult = (int)result;
68774   return jresult;
68775 }
68776
68777
68778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68779   int jresult ;
68780   int result;
68781
68782   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68783   jresult = (int)result;
68784   return jresult;
68785 }
68786
68787
68788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68789   int jresult ;
68790   int result;
68791
68792   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68793   jresult = (int)result;
68794   return jresult;
68795 }
68796
68797
68798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68799   int jresult ;
68800   int result;
68801
68802   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68803   jresult = (int)result;
68804   return jresult;
68805 }
68806
68807
68808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68809   int jresult ;
68810   int result;
68811
68812   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68813   jresult = (int)result;
68814   return jresult;
68815 }
68816
68817
68818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68819   int jresult ;
68820   int result;
68821
68822   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68823   jresult = (int)result;
68824   return jresult;
68825 }
68826
68827
68828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68829   int jresult ;
68830   int result;
68831
68832   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68833   jresult = (int)result;
68834   return jresult;
68835 }
68836
68837
68838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68839   int jresult ;
68840   int result;
68841
68842   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68843   jresult = (int)result;
68844   return jresult;
68845 }
68846
68847
68848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68849   int jresult ;
68850   int result;
68851
68852   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68853   jresult = (int)result;
68854   return jresult;
68855 }
68856
68857
68858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68859   int jresult ;
68860   int result;
68861
68862   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68863   jresult = (int)result;
68864   return jresult;
68865 }
68866
68867
68868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68869   int jresult ;
68870   int result;
68871
68872   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68873   jresult = (int)result;
68874   return jresult;
68875 }
68876
68877
68878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68879   int jresult ;
68880   int result;
68881
68882   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68883   jresult = (int)result;
68884   return jresult;
68885 }
68886
68887
68888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68889   void * jresult ;
68890   Dali::Toolkit::Scrollable::Property *result = 0 ;
68891
68892   {
68893     try {
68894       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68895     } catch (std::out_of_range& e) {
68896       {
68897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68898       };
68899     } catch (std::exception& e) {
68900       {
68901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68902       };
68903     } catch (...) {
68904       {
68905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68906       };
68907     }
68908   }
68909   jresult = (void *)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68915   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68916
68917   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68918   {
68919     try {
68920       delete arg1;
68921     } catch (std::out_of_range& e) {
68922       {
68923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68924       };
68925     } catch (std::exception& e) {
68926       {
68927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68928       };
68929     } catch (...) {
68930       {
68931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68932       };
68933     }
68934   }
68935 }
68936
68937
68938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68939   void * jresult ;
68940   Dali::Toolkit::Scrollable *result = 0 ;
68941
68942   {
68943     try {
68944       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68952       };
68953     } catch (...) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68956       };
68957     }
68958   }
68959   jresult = (void *)result;
68960   return jresult;
68961 }
68962
68963
68964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68965   void * jresult ;
68966   Dali::Toolkit::Scrollable *arg1 = 0 ;
68967   Dali::Toolkit::Scrollable *result = 0 ;
68968
68969   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68970   if (!arg1) {
68971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68972     return 0;
68973   }
68974   {
68975     try {
68976       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68977     } catch (std::out_of_range& e) {
68978       {
68979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68980       };
68981     } catch (std::exception& e) {
68982       {
68983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68984       };
68985     } catch (...) {
68986       {
68987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68988       };
68989     }
68990   }
68991   jresult = (void *)result;
68992   return jresult;
68993 }
68994
68995
68996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68997   void * jresult ;
68998   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68999   Dali::Toolkit::Scrollable *arg2 = 0 ;
69000   Dali::Toolkit::Scrollable *result = 0 ;
69001
69002   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69003   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69004   if (!arg2) {
69005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69006     return 0;
69007   }
69008   {
69009     try {
69010       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69011     } catch (std::out_of_range& e) {
69012       {
69013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69014       };
69015     } catch (std::exception& e) {
69016       {
69017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69018       };
69019     } catch (...) {
69020       {
69021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69022       };
69023     }
69024   }
69025   jresult = (void *)result;
69026   return jresult;
69027 }
69028
69029
69030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69031   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69032
69033   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69034   {
69035     try {
69036       delete arg1;
69037     } catch (std::out_of_range& e) {
69038       {
69039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69040       };
69041     } catch (std::exception& e) {
69042       {
69043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69044       };
69045     } catch (...) {
69046       {
69047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69048       };
69049     }
69050   }
69051 }
69052
69053
69054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69055   void * jresult ;
69056   Dali::BaseHandle arg1 ;
69057   Dali::BaseHandle *argp1 ;
69058   Dali::Toolkit::Scrollable result;
69059
69060   argp1 = (Dali::BaseHandle *)jarg1;
69061   if (!argp1) {
69062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69063     return 0;
69064   }
69065   arg1 = *argp1;
69066   {
69067     try {
69068       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69080       };
69081     }
69082   }
69083   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69089   unsigned int jresult ;
69090   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69091   bool result;
69092
69093   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69094   {
69095     try {
69096       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69097     } catch (std::out_of_range& e) {
69098       {
69099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (std::exception& e) {
69102       {
69103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69104       };
69105     } catch (...) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69108       };
69109     }
69110   }
69111   jresult = result;
69112   return jresult;
69113 }
69114
69115
69116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69117   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69118   bool arg2 ;
69119
69120   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69121   arg2 = jarg2 ? true : false;
69122   {
69123     try {
69124       (arg1)->SetOvershootEnabled(arg2);
69125     } catch (std::out_of_range& e) {
69126       {
69127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69128       };
69129     } catch (std::exception& e) {
69130       {
69131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69132       };
69133     } catch (...) {
69134       {
69135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69136       };
69137     }
69138   }
69139 }
69140
69141
69142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69143   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69144   Dali::Vector4 *arg2 = 0 ;
69145
69146   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69147   arg2 = (Dali::Vector4 *)jarg2;
69148   if (!arg2) {
69149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69150     return ;
69151   }
69152   {
69153     try {
69154       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69155     } catch (std::out_of_range& e) {
69156       {
69157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69158       };
69159     } catch (std::exception& e) {
69160       {
69161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69162       };
69163     } catch (...) {
69164       {
69165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69166       };
69167     }
69168   }
69169 }
69170
69171
69172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69173   void * jresult ;
69174   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69175   Dali::Vector4 result;
69176
69177   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69178   {
69179     try {
69180       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69192       };
69193     }
69194   }
69195   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69196   return jresult;
69197 }
69198
69199
69200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69201   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69202   float arg2 ;
69203
69204   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69205   arg2 = (float)jarg2;
69206   {
69207     try {
69208       (arg1)->SetOvershootAnimationSpeed(arg2);
69209     } catch (std::out_of_range& e) {
69210       {
69211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69212       };
69213     } catch (std::exception& e) {
69214       {
69215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69216       };
69217     } catch (...) {
69218       {
69219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69220       };
69221     }
69222   }
69223 }
69224
69225
69226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69227   float jresult ;
69228   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69229   float result;
69230
69231   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69232   {
69233     try {
69234       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69242       };
69243     } catch (...) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69246       };
69247     }
69248   }
69249   jresult = result;
69250   return jresult;
69251 }
69252
69253
69254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69255   void * jresult ;
69256   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69257   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69258
69259   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69260   {
69261     try {
69262       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69263     } catch (std::out_of_range& e) {
69264       {
69265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69266       };
69267     } catch (std::exception& e) {
69268       {
69269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (...) {
69272       {
69273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69274       };
69275     }
69276   }
69277   jresult = (void *)result;
69278   return jresult;
69279 }
69280
69281
69282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69283   void * jresult ;
69284   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69285   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69286
69287   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69288   {
69289     try {
69290       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69291     } catch (std::out_of_range& e) {
69292       {
69293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69294       };
69295     } catch (std::exception& e) {
69296       {
69297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69298       };
69299     } catch (...) {
69300       {
69301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69302       };
69303     }
69304   }
69305   jresult = (void *)result;
69306   return jresult;
69307 }
69308
69309
69310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69311   void * jresult ;
69312   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69313   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69314
69315   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69316   {
69317     try {
69318       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69319     } catch (std::out_of_range& e) {
69320       {
69321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69322       };
69323     } catch (std::exception& e) {
69324       {
69325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69330       };
69331     }
69332   }
69333   jresult = (void *)result;
69334   return jresult;
69335 }
69336
69337
69338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69339   unsigned int jresult ;
69340   Dali::Toolkit::ControlOrientation::Type arg1 ;
69341   bool result;
69342
69343   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69344   {
69345     try {
69346       result = (bool)Dali::Toolkit::IsVertical(arg1);
69347     } catch (std::out_of_range& e) {
69348       {
69349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69350       };
69351     } catch (std::exception& e) {
69352       {
69353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (...) {
69356       {
69357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69358       };
69359     }
69360   }
69361   jresult = result;
69362   return jresult;
69363 }
69364
69365
69366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69367   unsigned int jresult ;
69368   Dali::Toolkit::ControlOrientation::Type arg1 ;
69369   bool result;
69370
69371   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69372   {
69373     try {
69374       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69375     } catch (std::out_of_range& e) {
69376       {
69377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69378       };
69379     } catch (std::exception& e) {
69380       {
69381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69382       };
69383     } catch (...) {
69384       {
69385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69386       };
69387     }
69388   }
69389   jresult = result;
69390   return jresult;
69391 }
69392
69393
69394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69395   void * jresult ;
69396   unsigned int arg1 ;
69397   unsigned int arg2 ;
69398   Dali::Toolkit::ItemRange *result = 0 ;
69399
69400   arg1 = (unsigned int)jarg1;
69401   arg2 = (unsigned int)jarg2;
69402   {
69403     try {
69404       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (...) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69416       };
69417     }
69418   }
69419   jresult = (void *)result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69425   void * jresult ;
69426   Dali::Toolkit::ItemRange *arg1 = 0 ;
69427   Dali::Toolkit::ItemRange *result = 0 ;
69428
69429   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69430   if (!arg1) {
69431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69432     return 0;
69433   }
69434   {
69435     try {
69436       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69437     } catch (std::out_of_range& e) {
69438       {
69439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (std::exception& e) {
69442       {
69443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69444       };
69445     } catch (...) {
69446       {
69447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69448       };
69449     }
69450   }
69451   jresult = (void *)result;
69452   return jresult;
69453 }
69454
69455
69456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69457   void * jresult ;
69458   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69459   Dali::Toolkit::ItemRange *arg2 = 0 ;
69460   Dali::Toolkit::ItemRange *result = 0 ;
69461
69462   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69463   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69464   if (!arg2) {
69465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69466     return 0;
69467   }
69468   {
69469     try {
69470       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69471     } catch (std::out_of_range& e) {
69472       {
69473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69474       };
69475     } catch (std::exception& e) {
69476       {
69477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69478       };
69479     } catch (...) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69482       };
69483     }
69484   }
69485   jresult = (void *)result;
69486   return jresult;
69487 }
69488
69489
69490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69491   unsigned int jresult ;
69492   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69493   unsigned int arg2 ;
69494   bool result;
69495
69496   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69497   arg2 = (unsigned int)jarg2;
69498   {
69499     try {
69500       result = (bool)(arg1)->Within(arg2);
69501     } catch (std::out_of_range& e) {
69502       {
69503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69504       };
69505     } catch (std::exception& e) {
69506       {
69507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69508       };
69509     } catch (...) {
69510       {
69511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69512       };
69513     }
69514   }
69515   jresult = result;
69516   return jresult;
69517 }
69518
69519
69520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69521   void * jresult ;
69522   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69523   Dali::Toolkit::ItemRange *arg2 = 0 ;
69524   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69525
69526   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69527   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69528   if (!arg2) {
69529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69530     return 0;
69531   }
69532   {
69533     try {
69534       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69535     } catch (std::out_of_range& e) {
69536       {
69537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69538       };
69539     } catch (std::exception& e) {
69540       {
69541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69542       };
69543     } catch (...) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69546       };
69547     }
69548   }
69549   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69550   return jresult;
69551 }
69552
69553
69554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69555   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69556   unsigned int arg2 ;
69557
69558   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69559   arg2 = (unsigned int)jarg2;
69560   if (arg1) (arg1)->begin = arg2;
69561 }
69562
69563
69564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69565   unsigned int jresult ;
69566   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69567   unsigned int result;
69568
69569   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69570   result = (unsigned int) ((arg1)->begin);
69571   jresult = result;
69572   return jresult;
69573 }
69574
69575
69576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69577   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69578   unsigned int arg2 ;
69579
69580   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69581   arg2 = (unsigned int)jarg2;
69582   if (arg1) (arg1)->end = arg2;
69583 }
69584
69585
69586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69587   unsigned int jresult ;
69588   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69589   unsigned int result;
69590
69591   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69592   result = (unsigned int) ((arg1)->end);
69593   jresult = result;
69594   return jresult;
69595 }
69596
69597
69598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69599   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69600
69601   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69602   {
69603     try {
69604       delete arg1;
69605     } catch (std::out_of_range& e) {
69606       {
69607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69608       };
69609     } catch (std::exception& e) {
69610       {
69611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69616       };
69617     }
69618   }
69619 }
69620
69621
69622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69623   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69624
69625   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69626   {
69627     try {
69628       delete arg1;
69629     } catch (std::out_of_range& e) {
69630       {
69631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69632       };
69633     } catch (std::exception& e) {
69634       {
69635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69636       };
69637     } catch (...) {
69638       {
69639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69640       };
69641     }
69642   }
69643 }
69644
69645
69646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69647   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69648   Dali::Toolkit::ControlOrientation::Type arg2 ;
69649
69650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69651   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69652   {
69653     try {
69654       (arg1)->SetOrientation(arg2);
69655     } catch (std::out_of_range& e) {
69656       {
69657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69658       };
69659     } catch (std::exception& e) {
69660       {
69661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69662       };
69663     } catch (...) {
69664       {
69665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69666       };
69667     }
69668   }
69669 }
69670
69671
69672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69673   int jresult ;
69674   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69675   Dali::Toolkit::ControlOrientation::Type result;
69676
69677   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69678   {
69679     try {
69680       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69681     } catch (std::out_of_range& e) {
69682       {
69683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69684       };
69685     } catch (std::exception& e) {
69686       {
69687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69688       };
69689     } catch (...) {
69690       {
69691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69692       };
69693     }
69694   }
69695   jresult = (int)result;
69696   return jresult;
69697 }
69698
69699
69700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69701   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69702   Dali::Property::Map *arg2 = 0 ;
69703
69704   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69705   arg2 = (Dali::Property::Map *)jarg2;
69706   if (!arg2) {
69707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69708     return ;
69709   }
69710   {
69711     try {
69712       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69713     } catch (std::out_of_range& e) {
69714       {
69715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69716       };
69717     } catch (std::exception& e) {
69718       {
69719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69720       };
69721     } catch (...) {
69722       {
69723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69724       };
69725     }
69726   }
69727 }
69728
69729
69730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69731   void * jresult ;
69732   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69733   Dali::Property::Map result;
69734
69735   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69736   {
69737     try {
69738       result = (arg1)->GetLayoutProperties();
69739     } catch (std::out_of_range& e) {
69740       {
69741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69742       };
69743     } catch (std::exception& e) {
69744       {
69745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69750       };
69751     }
69752   }
69753   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69754   return jresult;
69755 }
69756
69757
69758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69759   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69760   unsigned int arg2 ;
69761   Dali::Vector3 *arg3 = 0 ;
69762   Dali::Vector3 *arg4 = 0 ;
69763
69764   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69765   arg2 = (unsigned int)jarg2;
69766   arg3 = (Dali::Vector3 *)jarg3;
69767   if (!arg3) {
69768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69769     return ;
69770   }
69771   arg4 = (Dali::Vector3 *)jarg4;
69772   if (!arg4) {
69773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69774     return ;
69775   }
69776   {
69777     try {
69778       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69779     } catch (std::out_of_range& e) {
69780       {
69781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69782       };
69783     } catch (std::exception& e) {
69784       {
69785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69786       };
69787     } catch (...) {
69788       {
69789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69790       };
69791     }
69792   }
69793 }
69794
69795
69796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69797   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69798   Dali::Vector3 *arg2 = 0 ;
69799
69800   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69801   arg2 = (Dali::Vector3 *)jarg2;
69802   if (!arg2) {
69803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69804     return ;
69805   }
69806   {
69807     try {
69808       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69809     } catch (std::out_of_range& e) {
69810       {
69811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69812       };
69813     } catch (std::exception& e) {
69814       {
69815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69816       };
69817     } catch (...) {
69818       {
69819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69820       };
69821     }
69822   }
69823 }
69824
69825
69826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69827   float jresult ;
69828   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69829   unsigned int arg2 ;
69830   Dali::Vector3 arg3 ;
69831   Dali::Vector3 *argp3 ;
69832   float result;
69833
69834   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69835   arg2 = (unsigned int)jarg2;
69836   argp3 = (Dali::Vector3 *)jarg3;
69837   if (!argp3) {
69838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69839     return 0;
69840   }
69841   arg3 = *argp3;
69842   {
69843     try {
69844       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69856       };
69857     }
69858   }
69859   jresult = result;
69860   return jresult;
69861 }
69862
69863
69864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69865   float jresult ;
69866   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69867   float arg2 ;
69868   float result;
69869
69870   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69871   arg2 = (float)jarg2;
69872   {
69873     try {
69874       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69875     } catch (std::out_of_range& e) {
69876       {
69877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (std::exception& e) {
69880       {
69881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69882       };
69883     } catch (...) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69886       };
69887     }
69888   }
69889   jresult = result;
69890   return jresult;
69891 }
69892
69893
69894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69895   float jresult ;
69896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69897   unsigned int arg2 ;
69898   float result;
69899
69900   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69901   arg2 = (unsigned int)jarg2;
69902   {
69903     try {
69904       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69905     } catch (std::out_of_range& e) {
69906       {
69907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (std::exception& e) {
69910       {
69911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (...) {
69914       {
69915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69916       };
69917     }
69918   }
69919   jresult = result;
69920   return jresult;
69921 }
69922
69923
69924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69925   void * jresult ;
69926   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69927   float arg2 ;
69928   Dali::Vector3 arg3 ;
69929   Dali::Vector3 *argp3 ;
69930   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69931
69932   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69933   arg2 = (float)jarg2;
69934   argp3 = (Dali::Vector3 *)jarg3;
69935   if (!argp3) {
69936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69937     return 0;
69938   }
69939   arg3 = *argp3;
69940   {
69941     try {
69942       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69950       };
69951     } catch (...) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69954       };
69955     }
69956   }
69957   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69963   float jresult ;
69964   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69965   int arg2 ;
69966   float arg3 ;
69967   Dali::Vector3 *arg4 = 0 ;
69968   float result;
69969
69970   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69971   arg2 = (int)jarg2;
69972   arg3 = (float)jarg3;
69973   arg4 = (Dali::Vector3 *)jarg4;
69974   if (!arg4) {
69975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69976     return 0;
69977   }
69978   {
69979     try {
69980       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69981     } catch (std::out_of_range& e) {
69982       {
69983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (std::exception& e) {
69986       {
69987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69992       };
69993     }
69994   }
69995   jresult = result;
69996   return jresult;
69997 }
69998
69999
70000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70001   unsigned int jresult ;
70002   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70003   Dali::Vector3 arg2 ;
70004   Dali::Vector3 *argp2 ;
70005   unsigned int result;
70006
70007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70008   argp2 = (Dali::Vector3 *)jarg2;
70009   if (!argp2) {
70010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70011     return 0;
70012   }
70013   arg2 = *argp2;
70014   {
70015     try {
70016       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70017     } catch (std::out_of_range& e) {
70018       {
70019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70020       };
70021     } catch (std::exception& e) {
70022       {
70023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70024       };
70025     } catch (...) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70028       };
70029     }
70030   }
70031   jresult = result;
70032   return jresult;
70033 }
70034
70035
70036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70037   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70038   unsigned int arg2 ;
70039   Dali::Vector3 *arg3 = 0 ;
70040   Dali::Vector3 *arg4 = 0 ;
70041
70042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70043   arg2 = (unsigned int)jarg2;
70044   arg3 = (Dali::Vector3 *)jarg3;
70045   if (!arg3) {
70046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70047     return ;
70048   }
70049   arg4 = (Dali::Vector3 *)jarg4;
70050   if (!arg4) {
70051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70052     return ;
70053   }
70054   {
70055     try {
70056       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70057     } catch (std::out_of_range& e) {
70058       {
70059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70060       };
70061     } catch (std::exception& e) {
70062       {
70063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70064       };
70065     } catch (...) {
70066       {
70067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70068       };
70069     }
70070   }
70071 }
70072
70073
70074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70075   void * jresult ;
70076   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70077   Dali::Degree result;
70078
70079   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70080   {
70081     try {
70082       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70083     } catch (std::out_of_range& e) {
70084       {
70085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (std::exception& e) {
70088       {
70089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70090       };
70091     } catch (...) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70094       };
70095     }
70096   }
70097   jresult = new Dali::Degree((const Dali::Degree &)result);
70098   return jresult;
70099 }
70100
70101
70102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70103   float jresult ;
70104   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70105   float result;
70106
70107   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70108   {
70109     try {
70110       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70111     } catch (std::out_of_range& e) {
70112       {
70113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (std::exception& e) {
70116       {
70117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70118       };
70119     } catch (...) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70122       };
70123     }
70124   }
70125   jresult = result;
70126   return jresult;
70127 }
70128
70129
70130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70131   float jresult ;
70132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70133   float result;
70134
70135   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70136   {
70137     try {
70138       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70139     } catch (std::out_of_range& e) {
70140       {
70141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (std::exception& e) {
70144       {
70145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (...) {
70148       {
70149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70150       };
70151     }
70152   }
70153   jresult = result;
70154   return jresult;
70155 }
70156
70157
70158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70159   float jresult ;
70160   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70161   float result;
70162
70163   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70164   {
70165     try {
70166       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70167     } catch (std::out_of_range& e) {
70168       {
70169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70170       };
70171     } catch (std::exception& e) {
70172       {
70173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70174       };
70175     } catch (...) {
70176       {
70177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70178       };
70179     }
70180   }
70181   jresult = result;
70182   return jresult;
70183 }
70184
70185
70186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70187   int jresult ;
70188   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70189   int arg2 ;
70190   int arg3 ;
70191   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70192   bool arg5 ;
70193   int result;
70194
70195   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70196   arg2 = (int)jarg2;
70197   arg3 = (int)jarg3;
70198   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70199   arg5 = jarg5 ? true : false;
70200   {
70201     try {
70202       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70203     } catch (std::out_of_range& e) {
70204       {
70205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70206       };
70207     } catch (std::exception& e) {
70208       {
70209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (...) {
70212       {
70213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70214       };
70215     }
70216   }
70217   jresult = result;
70218   return jresult;
70219 }
70220
70221
70222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70223   float jresult ;
70224   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70225   float result;
70226
70227   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70228   {
70229     try {
70230       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70231     } catch (std::out_of_range& e) {
70232       {
70233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70234       };
70235     } catch (std::exception& e) {
70236       {
70237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70238       };
70239     } catch (...) {
70240       {
70241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70242       };
70243     }
70244   }
70245   jresult = result;
70246   return jresult;
70247 }
70248
70249
70250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70251   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70252   Dali::Actor *arg2 = 0 ;
70253   int arg3 ;
70254   Dali::Vector3 *arg4 = 0 ;
70255   Dali::Actor *arg5 = 0 ;
70256
70257   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70258   arg2 = (Dali::Actor *)jarg2;
70259   if (!arg2) {
70260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70261     return ;
70262   }
70263   arg3 = (int)jarg3;
70264   arg4 = (Dali::Vector3 *)jarg4;
70265   if (!arg4) {
70266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70267     return ;
70268   }
70269   arg5 = (Dali::Actor *)jarg5;
70270   if (!arg5) {
70271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70272     return ;
70273   }
70274   {
70275     try {
70276       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70284       };
70285     } catch (...) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70288       };
70289     }
70290   }
70291 }
70292
70293
70294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70295   void * jresult ;
70296   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70297   int arg2 ;
70298   float arg3 ;
70299   Dali::Vector3 *arg4 = 0 ;
70300   Dali::Vector3 result;
70301
70302   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70303   arg2 = (int)jarg2;
70304   arg3 = (float)jarg3;
70305   arg4 = (Dali::Vector3 *)jarg4;
70306   if (!arg4) {
70307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70308     return 0;
70309   }
70310   {
70311     try {
70312       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70313     } catch (std::out_of_range& e) {
70314       {
70315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (std::exception& e) {
70318       {
70319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (...) {
70322       {
70323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70324       };
70325     }
70326   }
70327   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70328   return jresult;
70329 }
70330
70331
70332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70333   void * jresult ;
70334   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70335   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70336
70337   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70338   {
70339     try {
70340       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70341     } catch (std::out_of_range& e) {
70342       {
70343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70344       };
70345     } catch (std::exception& e) {
70346       {
70347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70348       };
70349     } catch (...) {
70350       {
70351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70352       };
70353     }
70354   }
70355   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70361   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70362
70363   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70364   {
70365     try {
70366       delete arg1;
70367     } catch (std::out_of_range& e) {
70368       {
70369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70370       };
70371     } catch (std::exception& e) {
70372       {
70373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70374       };
70375     } catch (...) {
70376       {
70377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70378       };
70379     }
70380   }
70381 }
70382
70383
70384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70385   unsigned int jresult ;
70386   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70387   unsigned int result;
70388
70389   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70390   {
70391     try {
70392       result = (unsigned int)(arg1)->GetNumberOfItems();
70393     } catch (std::out_of_range& e) {
70394       {
70395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70396       };
70397     } catch (std::exception& e) {
70398       {
70399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70400       };
70401     } catch (...) {
70402       {
70403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70404       };
70405     }
70406   }
70407   jresult = result;
70408   return jresult;
70409 }
70410
70411
70412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70413   void * jresult ;
70414   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70415   unsigned int arg2 ;
70416   Dali::Actor result;
70417
70418   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70419   arg2 = (unsigned int)jarg2;
70420   {
70421     try {
70422       result = (arg1)->NewItem(arg2);
70423     } catch (std::out_of_range& e) {
70424       {
70425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (std::exception& e) {
70428       {
70429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70430       };
70431     } catch (...) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70434       };
70435     }
70436   }
70437   jresult = new Dali::Actor((const Dali::Actor &)result);
70438   return jresult;
70439 }
70440
70441
70442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70443   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70444   unsigned int arg2 ;
70445   Dali::Actor arg3 ;
70446   Dali::Actor *argp3 ;
70447
70448   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70449   arg2 = (unsigned int)jarg2;
70450   argp3 = (Dali::Actor *)jarg3;
70451   if (!argp3) {
70452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70453     return ;
70454   }
70455   arg3 = *argp3;
70456   {
70457     try {
70458       (arg1)->ItemReleased(arg2,arg3);
70459     } catch (std::out_of_range& e) {
70460       {
70461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70462       };
70463     } catch (std::exception& e) {
70464       {
70465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70466       };
70467     } catch (...) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70470       };
70471     }
70472   }
70473 }
70474
70475
70476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70477   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70478   unsigned int arg2 ;
70479   Dali::Actor arg3 ;
70480   Dali::Actor *argp3 ;
70481
70482   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70483   arg2 = (unsigned int)jarg2;
70484   argp3 = (Dali::Actor *)jarg3;
70485   if (!argp3) {
70486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70487     return ;
70488   }
70489   arg3 = *argp3;
70490   {
70491     try {
70492       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70493     } catch (std::out_of_range& e) {
70494       {
70495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70496       };
70497     } catch (std::exception& e) {
70498       {
70499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70500       };
70501     } catch (...) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70504       };
70505     }
70506   }
70507 }
70508
70509
70510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70511   void * jresult ;
70512   Dali::Toolkit::ItemFactory *result = 0 ;
70513
70514   {
70515     try {
70516       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70517     } catch (std::out_of_range& e) {
70518       {
70519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70520       };
70521     } catch (std::exception& e) {
70522       {
70523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (...) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70528       };
70529     }
70530   }
70531   jresult = (void *)result;
70532   return jresult;
70533 }
70534
70535
70536 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) {
70537   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70538   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70539   if (director) {
70540     director->swig_connect_director(callback0, callback1, callback2);
70541   }
70542 }
70543
70544
70545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70546   int jresult ;
70547   int result;
70548
70549   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70550   jresult = (int)result;
70551   return jresult;
70552 }
70553
70554
70555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70556   int jresult ;
70557   int result;
70558
70559   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70560   jresult = (int)result;
70561   return jresult;
70562 }
70563
70564
70565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70566   int jresult ;
70567   int result;
70568
70569   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70570   jresult = (int)result;
70571   return jresult;
70572 }
70573
70574
70575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70576   int jresult ;
70577   int result;
70578
70579   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70580   jresult = (int)result;
70581   return jresult;
70582 }
70583
70584
70585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70586   int jresult ;
70587   int result;
70588
70589   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70590   jresult = (int)result;
70591   return jresult;
70592 }
70593
70594
70595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70596   int jresult ;
70597   int result;
70598
70599   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70600   jresult = (int)result;
70601   return jresult;
70602 }
70603
70604
70605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70606   int jresult ;
70607   int result;
70608
70609   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70610   jresult = (int)result;
70611   return jresult;
70612 }
70613
70614
70615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70616   int jresult ;
70617   int result;
70618
70619   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70620   jresult = (int)result;
70621   return jresult;
70622 }
70623
70624
70625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70626   int jresult ;
70627   int result;
70628
70629   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70630   jresult = (int)result;
70631   return jresult;
70632 }
70633
70634
70635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70636   int jresult ;
70637   int result;
70638
70639   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70640   jresult = (int)result;
70641   return jresult;
70642 }
70643
70644
70645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70646   int jresult ;
70647   int result;
70648
70649   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70650   jresult = (int)result;
70651   return jresult;
70652 }
70653
70654
70655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70656   void * jresult ;
70657   Dali::Toolkit::ItemView::Property *result = 0 ;
70658
70659   {
70660     try {
70661       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70662     } catch (std::out_of_range& e) {
70663       {
70664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (std::exception& e) {
70667       {
70668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70669       };
70670     } catch (...) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70673       };
70674     }
70675   }
70676   jresult = (void *)result;
70677   return jresult;
70678 }
70679
70680
70681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70682   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70683
70684   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70685   {
70686     try {
70687       delete arg1;
70688     } catch (std::out_of_range& e) {
70689       {
70690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70691       };
70692     } catch (std::exception& e) {
70693       {
70694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70695       };
70696     } catch (...) {
70697       {
70698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70699       };
70700     }
70701   }
70702 }
70703
70704
70705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70706   void * jresult ;
70707   Dali::Toolkit::ItemView *result = 0 ;
70708
70709   {
70710     try {
70711       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70712     } catch (std::out_of_range& e) {
70713       {
70714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70715       };
70716     } catch (std::exception& e) {
70717       {
70718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70719       };
70720     } catch (...) {
70721       {
70722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70723       };
70724     }
70725   }
70726   jresult = (void *)result;
70727   return jresult;
70728 }
70729
70730
70731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70732   void * jresult ;
70733   Dali::Toolkit::ItemView *arg1 = 0 ;
70734   Dali::Toolkit::ItemView *result = 0 ;
70735
70736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70737   if (!arg1) {
70738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70739     return 0;
70740   }
70741   {
70742     try {
70743       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70744     } catch (std::out_of_range& e) {
70745       {
70746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70747       };
70748     } catch (std::exception& e) {
70749       {
70750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70751       };
70752     } catch (...) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70755       };
70756     }
70757   }
70758   jresult = (void *)result;
70759   return jresult;
70760 }
70761
70762
70763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70764   void * jresult ;
70765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70766   Dali::Toolkit::ItemView *arg2 = 0 ;
70767   Dali::Toolkit::ItemView *result = 0 ;
70768
70769   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70770   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70771   if (!arg2) {
70772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70773     return 0;
70774   }
70775   {
70776     try {
70777       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70778     } catch (std::out_of_range& e) {
70779       {
70780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (std::exception& e) {
70783       {
70784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70785       };
70786     } catch (...) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70789       };
70790     }
70791   }
70792   jresult = (void *)result;
70793   return jresult;
70794 }
70795
70796
70797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70799
70800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70801   {
70802     try {
70803       delete arg1;
70804     } catch (std::out_of_range& e) {
70805       {
70806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70807       };
70808     } catch (std::exception& e) {
70809       {
70810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70815       };
70816     }
70817   }
70818 }
70819
70820
70821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70822   void * jresult ;
70823   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70824   Dali::Toolkit::ItemView result;
70825
70826   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70827   if (!arg1) {
70828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70829     return 0;
70830   }
70831   {
70832     try {
70833       result = Dali::Toolkit::ItemView::New(*arg1);
70834     } catch (std::out_of_range& e) {
70835       {
70836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70837       };
70838     } catch (std::exception& e) {
70839       {
70840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70841       };
70842     } catch (...) {
70843       {
70844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70845       };
70846     }
70847   }
70848   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70849   return jresult;
70850 }
70851
70852
70853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70854   void * jresult ;
70855   Dali::BaseHandle arg1 ;
70856   Dali::BaseHandle *argp1 ;
70857   Dali::Toolkit::ItemView result;
70858
70859   argp1 = (Dali::BaseHandle *)jarg1;
70860   if (!argp1) {
70861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70862     return 0;
70863   }
70864   arg1 = *argp1;
70865   {
70866     try {
70867       result = Dali::Toolkit::ItemView::DownCast(arg1);
70868     } catch (std::out_of_range& e) {
70869       {
70870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70871       };
70872     } catch (std::exception& e) {
70873       {
70874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70875       };
70876     } catch (...) {
70877       {
70878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70879       };
70880     }
70881   }
70882   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70883   return jresult;
70884 }
70885
70886
70887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70888   unsigned int jresult ;
70889   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70890   unsigned int result;
70891
70892   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70893   {
70894     try {
70895       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70896     } catch (std::out_of_range& e) {
70897       {
70898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70899       };
70900     } catch (std::exception& e) {
70901       {
70902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70903       };
70904     } catch (...) {
70905       {
70906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70907       };
70908     }
70909   }
70910   jresult = result;
70911   return jresult;
70912 }
70913
70914
70915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70917   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70918
70919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70920   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70921   if (!arg2) {
70922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70923     return ;
70924   }
70925   {
70926     try {
70927       (arg1)->AddLayout(*arg2);
70928     } catch (std::out_of_range& e) {
70929       {
70930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70931       };
70932     } catch (std::exception& e) {
70933       {
70934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70935       };
70936     } catch (...) {
70937       {
70938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70939       };
70940     }
70941   }
70942 }
70943
70944
70945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70947   unsigned int arg2 ;
70948
70949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70950   arg2 = (unsigned int)jarg2;
70951   {
70952     try {
70953       (arg1)->RemoveLayout(arg2);
70954     } catch (std::out_of_range& e) {
70955       {
70956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70957       };
70958     } catch (std::exception& e) {
70959       {
70960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70961       };
70962     } catch (...) {
70963       {
70964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70965       };
70966     }
70967   }
70968 }
70969
70970
70971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70972   void * jresult ;
70973   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70974   unsigned int arg2 ;
70975   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70976
70977   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70978   arg2 = (unsigned int)jarg2;
70979   {
70980     try {
70981       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70982     } catch (std::out_of_range& e) {
70983       {
70984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70985       };
70986     } catch (std::exception& e) {
70987       {
70988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70989       };
70990     } catch (...) {
70991       {
70992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70993       };
70994     }
70995   }
70996   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70997   return jresult;
70998 }
70999
71000
71001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71002   void * jresult ;
71003   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71004   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71005
71006   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71007   {
71008     try {
71009       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71010     } catch (std::out_of_range& e) {
71011       {
71012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71013       };
71014     } catch (std::exception& e) {
71015       {
71016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71017       };
71018     } catch (...) {
71019       {
71020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71021       };
71022     }
71023   }
71024   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71025   return jresult;
71026 }
71027
71028
71029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71030   float jresult ;
71031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71032   Dali::Toolkit::ItemId arg2 ;
71033   float result;
71034
71035   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71036   arg2 = (Dali::Toolkit::ItemId)jarg2;
71037   {
71038     try {
71039       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71040     } catch (std::out_of_range& e) {
71041       {
71042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71043       };
71044     } catch (std::exception& e) {
71045       {
71046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71047       };
71048     } catch (...) {
71049       {
71050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71051       };
71052     }
71053   }
71054   jresult = result;
71055   return jresult;
71056 }
71057
71058
71059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71060   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71061   unsigned int arg2 ;
71062   Dali::Vector3 arg3 ;
71063   float arg4 ;
71064   Dali::Vector3 *argp3 ;
71065
71066   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71067   arg2 = (unsigned int)jarg2;
71068   argp3 = (Dali::Vector3 *)jarg3;
71069   if (!argp3) {
71070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71071     return ;
71072   }
71073   arg3 = *argp3;
71074   arg4 = (float)jarg4;
71075   {
71076     try {
71077       (arg1)->ActivateLayout(arg2,arg3,arg4);
71078     } catch (std::out_of_range& e) {
71079       {
71080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71081       };
71082     } catch (std::exception& e) {
71083       {
71084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71085       };
71086     } catch (...) {
71087       {
71088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71089       };
71090     }
71091   }
71092 }
71093
71094
71095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71096   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71097
71098   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71099   {
71100     try {
71101       (arg1)->DeactivateCurrentLayout();
71102     } catch (std::out_of_range& e) {
71103       {
71104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71105       };
71106     } catch (std::exception& e) {
71107       {
71108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71109       };
71110     } catch (...) {
71111       {
71112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71113       };
71114     }
71115   }
71116 }
71117
71118
71119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71120   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71121   float arg2 ;
71122
71123   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71124   arg2 = (float)jarg2;
71125   {
71126     try {
71127       (arg1)->SetMinimumSwipeSpeed(arg2);
71128     } catch (std::out_of_range& e) {
71129       {
71130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71131       };
71132     } catch (std::exception& e) {
71133       {
71134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71135       };
71136     } catch (...) {
71137       {
71138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71139       };
71140     }
71141   }
71142 }
71143
71144
71145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71146   float jresult ;
71147   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71148   float result;
71149
71150   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71151   {
71152     try {
71153       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71154     } catch (std::out_of_range& e) {
71155       {
71156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71157       };
71158     } catch (std::exception& e) {
71159       {
71160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71161       };
71162     } catch (...) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71165       };
71166     }
71167   }
71168   jresult = result;
71169   return jresult;
71170 }
71171
71172
71173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71174   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71175   float arg2 ;
71176
71177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71178   arg2 = (float)jarg2;
71179   {
71180     try {
71181       (arg1)->SetMinimumSwipeDistance(arg2);
71182     } catch (std::out_of_range& e) {
71183       {
71184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71185       };
71186     } catch (std::exception& e) {
71187       {
71188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71189       };
71190     } catch (...) {
71191       {
71192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71193       };
71194     }
71195   }
71196 }
71197
71198
71199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71200   float jresult ;
71201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71202   float result;
71203
71204   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71205   {
71206     try {
71207       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71208     } catch (std::out_of_range& e) {
71209       {
71210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (std::exception& e) {
71213       {
71214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71215       };
71216     } catch (...) {
71217       {
71218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71219       };
71220     }
71221   }
71222   jresult = result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71229   float arg2 ;
71230
71231   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71232   arg2 = (float)jarg2;
71233   {
71234     try {
71235       (arg1)->SetWheelScrollDistanceStep(arg2);
71236     } catch (std::out_of_range& e) {
71237       {
71238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71239       };
71240     } catch (std::exception& e) {
71241       {
71242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71243       };
71244     } catch (...) {
71245       {
71246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71247       };
71248     }
71249   }
71250 }
71251
71252
71253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71254   float jresult ;
71255   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71256   float result;
71257
71258   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71259   {
71260     try {
71261       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71262     } catch (std::out_of_range& e) {
71263       {
71264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71265       };
71266     } catch (std::exception& e) {
71267       {
71268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71269       };
71270     } catch (...) {
71271       {
71272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71273       };
71274     }
71275   }
71276   jresult = result;
71277   return jresult;
71278 }
71279
71280
71281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71282   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71283   bool arg2 ;
71284
71285   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71286   arg2 = jarg2 ? true : false;
71287   {
71288     try {
71289       (arg1)->SetAnchoring(arg2);
71290     } catch (std::out_of_range& e) {
71291       {
71292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71293       };
71294     } catch (std::exception& e) {
71295       {
71296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71297       };
71298     } catch (...) {
71299       {
71300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71301       };
71302     }
71303   }
71304 }
71305
71306
71307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71308   unsigned int jresult ;
71309   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71310   bool result;
71311
71312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71313   {
71314     try {
71315       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71316     } catch (std::out_of_range& e) {
71317       {
71318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71319       };
71320     } catch (std::exception& e) {
71321       {
71322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71323       };
71324     } catch (...) {
71325       {
71326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71327       };
71328     }
71329   }
71330   jresult = result;
71331   return jresult;
71332 }
71333
71334
71335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71336   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71337   float arg2 ;
71338
71339   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71340   arg2 = (float)jarg2;
71341   {
71342     try {
71343       (arg1)->SetAnchoringDuration(arg2);
71344     } catch (std::out_of_range& e) {
71345       {
71346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71347       };
71348     } catch (std::exception& e) {
71349       {
71350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71351       };
71352     } catch (...) {
71353       {
71354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71355       };
71356     }
71357   }
71358 }
71359
71360
71361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71362   float jresult ;
71363   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71364   float result;
71365
71366   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71367   {
71368     try {
71369       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71370     } catch (std::out_of_range& e) {
71371       {
71372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71373       };
71374     } catch (std::exception& e) {
71375       {
71376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71377       };
71378     } catch (...) {
71379       {
71380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71381       };
71382     }
71383   }
71384   jresult = result;
71385   return jresult;
71386 }
71387
71388
71389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71390   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71391   Dali::Toolkit::ItemId arg2 ;
71392   float arg3 ;
71393
71394   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71395   arg2 = (Dali::Toolkit::ItemId)jarg2;
71396   arg3 = (float)jarg3;
71397   {
71398     try {
71399       (arg1)->ScrollToItem(arg2,arg3);
71400     } catch (std::out_of_range& e) {
71401       {
71402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71403       };
71404     } catch (std::exception& e) {
71405       {
71406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71407       };
71408     } catch (...) {
71409       {
71410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71411       };
71412     }
71413   }
71414 }
71415
71416
71417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71418   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71419   float arg2 ;
71420
71421   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71422   arg2 = (float)jarg2;
71423   {
71424     try {
71425       (arg1)->SetRefreshInterval(arg2);
71426     } catch (std::out_of_range& e) {
71427       {
71428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71429       };
71430     } catch (std::exception& e) {
71431       {
71432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71437       };
71438     }
71439   }
71440 }
71441
71442
71443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71444   float jresult ;
71445   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71446   float result;
71447
71448   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71449   {
71450     try {
71451       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71452     } catch (std::out_of_range& e) {
71453       {
71454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71455       };
71456     } catch (std::exception& e) {
71457       {
71458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71459       };
71460     } catch (...) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71463       };
71464     }
71465   }
71466   jresult = result;
71467   return jresult;
71468 }
71469
71470
71471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71473
71474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71475   {
71476     try {
71477       (arg1)->Refresh();
71478     } catch (std::out_of_range& e) {
71479       {
71480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71481       };
71482     } catch (std::exception& e) {
71483       {
71484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71485       };
71486     } catch (...) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71489       };
71490     }
71491   }
71492 }
71493
71494
71495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71496   void * jresult ;
71497   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71498   Dali::Toolkit::ItemId arg2 ;
71499   Dali::Actor result;
71500
71501   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71502   arg2 = (Dali::Toolkit::ItemId)jarg2;
71503   {
71504     try {
71505       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71506     } catch (std::out_of_range& e) {
71507       {
71508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71509       };
71510     } catch (std::exception& e) {
71511       {
71512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71513       };
71514     } catch (...) {
71515       {
71516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71517       };
71518     }
71519   }
71520   jresult = new Dali::Actor((const Dali::Actor &)result);
71521   return jresult;
71522 }
71523
71524
71525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71526   unsigned int jresult ;
71527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71528   Dali::Actor arg2 ;
71529   Dali::Actor *argp2 ;
71530   Dali::Toolkit::ItemId result;
71531
71532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71533   argp2 = (Dali::Actor *)jarg2;
71534   if (!argp2) {
71535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71536     return 0;
71537   }
71538   arg2 = *argp2;
71539   {
71540     try {
71541       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71542     } catch (std::out_of_range& e) {
71543       {
71544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71545       };
71546     } catch (std::exception& e) {
71547       {
71548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71549       };
71550     } catch (...) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71553       };
71554     }
71555   }
71556   jresult = result;
71557   return jresult;
71558 }
71559
71560
71561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71562   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71563   Dali::Toolkit::Item arg2 ;
71564   float arg3 ;
71565   Dali::Toolkit::Item *argp2 ;
71566
71567   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71568   argp2 = (Dali::Toolkit::Item *)jarg2;
71569   if (!argp2) {
71570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71571     return ;
71572   }
71573   arg2 = *argp2;
71574   arg3 = (float)jarg3;
71575   {
71576     try {
71577       (arg1)->InsertItem(arg2,arg3);
71578     } catch (std::out_of_range& e) {
71579       {
71580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71581       };
71582     } catch (std::exception& e) {
71583       {
71584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71585       };
71586     } catch (...) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71589       };
71590     }
71591   }
71592 }
71593
71594
71595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71596   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71597   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71598   float arg3 ;
71599
71600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71601   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71602   if (!arg2) {
71603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71604     return ;
71605   }
71606   arg3 = (float)jarg3;
71607   {
71608     try {
71609       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71610     } catch (std::out_of_range& e) {
71611       {
71612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71613       };
71614     } catch (std::exception& e) {
71615       {
71616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71617       };
71618     } catch (...) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71621       };
71622     }
71623   }
71624 }
71625
71626
71627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71628   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71629   Dali::Toolkit::ItemId arg2 ;
71630   float arg3 ;
71631
71632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71633   arg2 = (Dali::Toolkit::ItemId)jarg2;
71634   arg3 = (float)jarg3;
71635   {
71636     try {
71637       (arg1)->RemoveItem(arg2,arg3);
71638     } catch (std::out_of_range& e) {
71639       {
71640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71641       };
71642     } catch (std::exception& e) {
71643       {
71644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71645       };
71646     } catch (...) {
71647       {
71648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71649       };
71650     }
71651   }
71652 }
71653
71654
71655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71656   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71657   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71658   float arg3 ;
71659
71660   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71661   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71662   if (!arg2) {
71663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71664     return ;
71665   }
71666   arg3 = (float)jarg3;
71667   {
71668     try {
71669       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71670     } catch (std::out_of_range& e) {
71671       {
71672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71673       };
71674     } catch (std::exception& e) {
71675       {
71676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71677       };
71678     } catch (...) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71681       };
71682     }
71683   }
71684 }
71685
71686
71687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71688   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71689   Dali::Toolkit::Item arg2 ;
71690   float arg3 ;
71691   Dali::Toolkit::Item *argp2 ;
71692
71693   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71694   argp2 = (Dali::Toolkit::Item *)jarg2;
71695   if (!argp2) {
71696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71697     return ;
71698   }
71699   arg2 = *argp2;
71700   arg3 = (float)jarg3;
71701   {
71702     try {
71703       (arg1)->ReplaceItem(arg2,arg3);
71704     } catch (std::out_of_range& e) {
71705       {
71706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71707       };
71708     } catch (std::exception& e) {
71709       {
71710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71715       };
71716     }
71717   }
71718 }
71719
71720
71721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71722   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71723   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71724   float arg3 ;
71725
71726   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71727   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71728   if (!arg2) {
71729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71730     return ;
71731   }
71732   arg3 = (float)jarg3;
71733   {
71734     try {
71735       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71736     } catch (std::out_of_range& e) {
71737       {
71738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71739       };
71740     } catch (std::exception& e) {
71741       {
71742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71743       };
71744     } catch (...) {
71745       {
71746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71747       };
71748     }
71749   }
71750 }
71751
71752
71753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71754   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71755   Dali::Vector3 *arg2 = 0 ;
71756
71757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71758   arg2 = (Dali::Vector3 *)jarg2;
71759   if (!arg2) {
71760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71761     return ;
71762   }
71763   {
71764     try {
71765       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71766     } catch (std::out_of_range& e) {
71767       {
71768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71769       };
71770     } catch (std::exception& e) {
71771       {
71772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71773       };
71774     } catch (...) {
71775       {
71776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71777       };
71778     }
71779   }
71780 }
71781
71782
71783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71784   void * jresult ;
71785   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71786   Dali::Vector3 result;
71787
71788   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71789   {
71790     try {
71791       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71792     } catch (std::out_of_range& e) {
71793       {
71794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (std::exception& e) {
71797       {
71798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71803       };
71804     }
71805   }
71806   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71807   return jresult;
71808 }
71809
71810
71811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71812   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71813   Dali::Vector3 *arg2 = 0 ;
71814
71815   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71816   arg2 = (Dali::Vector3 *)jarg2;
71817   if (!arg2) {
71818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71819     return ;
71820   }
71821   {
71822     try {
71823       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71824     } catch (std::out_of_range& e) {
71825       {
71826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71827       };
71828     } catch (std::exception& e) {
71829       {
71830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71835       };
71836     }
71837   }
71838 }
71839
71840
71841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71842   void * jresult ;
71843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71844   Dali::Vector3 result;
71845
71846   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71847   {
71848     try {
71849       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71850     } catch (std::out_of_range& e) {
71851       {
71852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71853       };
71854     } catch (std::exception& e) {
71855       {
71856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71857       };
71858     } catch (...) {
71859       {
71860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71861       };
71862     }
71863   }
71864   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71865   return jresult;
71866 }
71867
71868
71869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71871   Dali::Toolkit::ItemRange *arg2 = 0 ;
71872
71873   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71874   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71875   if (!arg2) {
71876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71877     return ;
71878   }
71879   {
71880     try {
71881       (arg1)->GetItemsRange(*arg2);
71882     } catch (std::out_of_range& e) {
71883       {
71884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71885       };
71886     } catch (std::exception& e) {
71887       {
71888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71889       };
71890     } catch (...) {
71891       {
71892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71893       };
71894     }
71895   }
71896 }
71897
71898
71899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71900   void * jresult ;
71901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71902   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71903
71904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71905   {
71906     try {
71907       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71908     } catch (std::out_of_range& e) {
71909       {
71910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71911       };
71912     } catch (std::exception& e) {
71913       {
71914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71915       };
71916     } catch (...) {
71917       {
71918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71919       };
71920     }
71921   }
71922   jresult = (void *)result;
71923   return jresult;
71924 }
71925
71926
71927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71928   Dali::Vector3 *arg1 = 0 ;
71929   PropertyInputContainer *arg2 = 0 ;
71930
71931   arg1 = (Dali::Vector3 *)jarg1;
71932   if (!arg1) {
71933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71934     return ;
71935   }
71936   arg2 = (PropertyInputContainer *)jarg2;
71937   if (!arg2) {
71938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71939     return ;
71940   }
71941   {
71942     try {
71943       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71944     } catch (std::out_of_range& e) {
71945       {
71946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71947       };
71948     } catch (std::exception& e) {
71949       {
71950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71951       };
71952     } catch (...) {
71953       {
71954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71955       };
71956     }
71957   }
71958 }
71959
71960
71961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71962   Dali::Vector3 *arg1 = 0 ;
71963   PropertyInputContainer *arg2 = 0 ;
71964
71965   arg1 = (Dali::Vector3 *)jarg1;
71966   if (!arg1) {
71967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71968     return ;
71969   }
71970   arg2 = (PropertyInputContainer *)jarg2;
71971   if (!arg2) {
71972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71973     return ;
71974   }
71975   {
71976     try {
71977       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71978     } catch (std::out_of_range& e) {
71979       {
71980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71981       };
71982     } catch (std::exception& e) {
71983       {
71984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71985       };
71986     } catch (...) {
71987       {
71988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71989       };
71990     }
71991   }
71992 }
71993
71994
71995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71996   void * jresult ;
71997   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71998
71999   {
72000     try {
72001       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72002     } catch (std::out_of_range& e) {
72003       {
72004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72005       };
72006     } catch (std::exception& e) {
72007       {
72008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72009       };
72010     } catch (...) {
72011       {
72012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72013       };
72014     }
72015   }
72016   jresult = (void *)result;
72017   return jresult;
72018 }
72019
72020
72021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72022   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72023
72024   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72025   {
72026     try {
72027       delete arg1;
72028     } catch (std::out_of_range& e) {
72029       {
72030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72031       };
72032     } catch (std::exception& e) {
72033       {
72034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72035       };
72036     } catch (...) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72039       };
72040     }
72041   }
72042 }
72043
72044
72045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72046   void * jresult ;
72047   Dali::Path arg1 ;
72048   Dali::Vector3 *arg2 = 0 ;
72049   Dali::Property::Index arg3 ;
72050   Dali::Vector3 *arg4 = 0 ;
72051   unsigned int arg5 ;
72052   Dali::Path *argp1 ;
72053   Dali::Toolkit::ScrollViewPagePathEffect result;
72054
72055   argp1 = (Dali::Path *)jarg1;
72056   if (!argp1) {
72057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72058     return 0;
72059   }
72060   arg1 = *argp1;
72061   arg2 = (Dali::Vector3 *)jarg2;
72062   if (!arg2) {
72063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72064     return 0;
72065   }
72066   arg3 = (Dali::Property::Index)jarg3;
72067   arg4 = (Dali::Vector3 *)jarg4;
72068   if (!arg4) {
72069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72070     return 0;
72071   }
72072   arg5 = (unsigned int)jarg5;
72073   {
72074     try {
72075       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72076     } catch (std::out_of_range& e) {
72077       {
72078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72079       };
72080     } catch (std::exception& e) {
72081       {
72082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72083       };
72084     } catch (...) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72087       };
72088     }
72089   }
72090   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72091   return jresult;
72092 }
72093
72094
72095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72096   void * jresult ;
72097   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72098
72099   {
72100     try {
72101       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72102     } catch (std::out_of_range& e) {
72103       {
72104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72105       };
72106     } catch (std::exception& e) {
72107       {
72108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (...) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72113       };
72114     }
72115   }
72116   jresult = (void *)result;
72117   return jresult;
72118 }
72119
72120
72121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72122   void * jresult ;
72123   Dali::BaseHandle arg1 ;
72124   Dali::BaseHandle *argp1 ;
72125   Dali::Toolkit::ScrollViewPagePathEffect result;
72126
72127   argp1 = (Dali::BaseHandle *)jarg1;
72128   if (!argp1) {
72129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72130     return 0;
72131   }
72132   arg1 = *argp1;
72133   {
72134     try {
72135       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72136     } catch (std::out_of_range& e) {
72137       {
72138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72139       };
72140     } catch (std::exception& e) {
72141       {
72142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72143       };
72144     } catch (...) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72147       };
72148     }
72149   }
72150   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72151   return jresult;
72152 }
72153
72154
72155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72156   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72157   Dali::Actor arg2 ;
72158   unsigned int arg3 ;
72159   Dali::Actor *argp2 ;
72160
72161   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72162   argp2 = (Dali::Actor *)jarg2;
72163   if (!argp2) {
72164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72165     return ;
72166   }
72167   arg2 = *argp2;
72168   arg3 = (unsigned int)jarg3;
72169   {
72170     try {
72171       (arg1)->ApplyToPage(arg2,arg3);
72172     } catch (std::out_of_range& e) {
72173       {
72174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72175       };
72176     } catch (std::exception& e) {
72177       {
72178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72183       };
72184     }
72185   }
72186 }
72187
72188
72189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72190   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72191
72192   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72193   {
72194     try {
72195       delete arg1;
72196     } catch (std::out_of_range& e) {
72197       {
72198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72199       };
72200     } catch (std::exception& e) {
72201       {
72202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72203       };
72204     } catch (...) {
72205       {
72206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72207       };
72208     }
72209   }
72210 }
72211
72212
72213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72214   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72215   Dali::Toolkit::ClampState arg2 ;
72216
72217   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72218   arg2 = (Dali::Toolkit::ClampState)jarg2;
72219   if (arg1) (arg1)->x = arg2;
72220 }
72221
72222
72223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72224   int jresult ;
72225   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72226   Dali::Toolkit::ClampState result;
72227
72228   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72229   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72230   jresult = (int)result;
72231   return jresult;
72232 }
72233
72234
72235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72236   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72237   Dali::Toolkit::ClampState arg2 ;
72238
72239   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72240   arg2 = (Dali::Toolkit::ClampState)jarg2;
72241   if (arg1) (arg1)->y = arg2;
72242 }
72243
72244
72245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72246   int jresult ;
72247   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72248   Dali::Toolkit::ClampState result;
72249
72250   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72251   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72252   jresult = (int)result;
72253   return jresult;
72254 }
72255
72256
72257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72258   void * jresult ;
72259   Dali::Toolkit::ClampState2D *result = 0 ;
72260
72261   {
72262     try {
72263       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72264     } catch (std::out_of_range& e) {
72265       {
72266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72267       };
72268     } catch (std::exception& e) {
72269       {
72270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72271       };
72272     } catch (...) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72275       };
72276     }
72277   }
72278   jresult = (void *)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72284   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72285
72286   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72287   {
72288     try {
72289       delete arg1;
72290     } catch (std::out_of_range& e) {
72291       {
72292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72293       };
72294     } catch (std::exception& e) {
72295       {
72296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72297       };
72298     } catch (...) {
72299       {
72300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72301       };
72302     }
72303   }
72304 }
72305
72306
72307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72308   void * jresult ;
72309   float arg1 ;
72310   float arg2 ;
72311   bool arg3 ;
72312   Dali::Toolkit::RulerDomain *result = 0 ;
72313
72314   arg1 = (float)jarg1;
72315   arg2 = (float)jarg2;
72316   arg3 = jarg3 ? true : false;
72317   {
72318     try {
72319       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72320     } catch (std::out_of_range& e) {
72321       {
72322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72323       };
72324     } catch (std::exception& e) {
72325       {
72326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72327       };
72328     } catch (...) {
72329       {
72330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72331       };
72332     }
72333   }
72334   jresult = (void *)result;
72335   return jresult;
72336 }
72337
72338
72339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72340   void * jresult ;
72341   float arg1 ;
72342   float arg2 ;
72343   Dali::Toolkit::RulerDomain *result = 0 ;
72344
72345   arg1 = (float)jarg1;
72346   arg2 = (float)jarg2;
72347   {
72348     try {
72349       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72350     } catch (std::out_of_range& e) {
72351       {
72352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (std::exception& e) {
72355       {
72356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (...) {
72359       {
72360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72361       };
72362     }
72363   }
72364   jresult = (void *)result;
72365   return jresult;
72366 }
72367
72368
72369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72371   float arg2 ;
72372
72373   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72374   arg2 = (float)jarg2;
72375   if (arg1) (arg1)->min = arg2;
72376 }
72377
72378
72379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72380   float jresult ;
72381   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72382   float result;
72383
72384   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72385   result = (float) ((arg1)->min);
72386   jresult = result;
72387   return jresult;
72388 }
72389
72390
72391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72392   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72393   float arg2 ;
72394
72395   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72396   arg2 = (float)jarg2;
72397   if (arg1) (arg1)->max = arg2;
72398 }
72399
72400
72401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72402   float jresult ;
72403   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72404   float result;
72405
72406   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72407   result = (float) ((arg1)->max);
72408   jresult = result;
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72414   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72415   bool arg2 ;
72416
72417   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72418   arg2 = jarg2 ? true : false;
72419   if (arg1) (arg1)->enabled = arg2;
72420 }
72421
72422
72423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72424   unsigned int jresult ;
72425   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72426   bool result;
72427
72428   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72429   result = (bool) ((arg1)->enabled);
72430   jresult = result;
72431   return jresult;
72432 }
72433
72434
72435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72436   float jresult ;
72437   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72438   float arg2 ;
72439   float arg3 ;
72440   float arg4 ;
72441   float result;
72442
72443   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72444   arg2 = (float)jarg2;
72445   arg3 = (float)jarg3;
72446   arg4 = (float)jarg4;
72447   {
72448     try {
72449       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72450     } catch (std::out_of_range& e) {
72451       {
72452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72453       };
72454     } catch (std::exception& e) {
72455       {
72456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72457       };
72458     } catch (...) {
72459       {
72460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72461       };
72462     }
72463   }
72464   jresult = result;
72465   return jresult;
72466 }
72467
72468
72469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72470   float jresult ;
72471   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72472   float arg2 ;
72473   float arg3 ;
72474   float result;
72475
72476   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72477   arg2 = (float)jarg2;
72478   arg3 = (float)jarg3;
72479   {
72480     try {
72481       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72482     } catch (std::out_of_range& e) {
72483       {
72484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72485       };
72486     } catch (std::exception& e) {
72487       {
72488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (...) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72493       };
72494     }
72495   }
72496   jresult = result;
72497   return jresult;
72498 }
72499
72500
72501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72502   float jresult ;
72503   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72504   float arg2 ;
72505   float result;
72506
72507   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72508   arg2 = (float)jarg2;
72509   {
72510     try {
72511       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72512     } catch (std::out_of_range& e) {
72513       {
72514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (std::exception& e) {
72517       {
72518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72519       };
72520     } catch (...) {
72521       {
72522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72523       };
72524     }
72525   }
72526   jresult = result;
72527   return jresult;
72528 }
72529
72530
72531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72532   float jresult ;
72533   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72534   float arg2 ;
72535   float arg3 ;
72536   float arg4 ;
72537   Dali::Toolkit::ClampState *arg5 = 0 ;
72538   float result;
72539
72540   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72541   arg2 = (float)jarg2;
72542   arg3 = (float)jarg3;
72543   arg4 = (float)jarg4;
72544   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72545   if (!arg5) {
72546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72547     return 0;
72548   }
72549   {
72550     try {
72551       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
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 (...) {
72561       {
72562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72563       };
72564     }
72565   }
72566   jresult = result;
72567   return jresult;
72568 }
72569
72570
72571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72572   float jresult ;
72573   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72574   float result;
72575
72576   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72577   {
72578     try {
72579       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72580     } catch (std::out_of_range& e) {
72581       {
72582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72583       };
72584     } catch (std::exception& e) {
72585       {
72586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72587       };
72588     } catch (...) {
72589       {
72590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72591       };
72592     }
72593   }
72594   jresult = result;
72595   return jresult;
72596 }
72597
72598
72599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72600   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72601
72602   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72603   {
72604     try {
72605       delete arg1;
72606     } catch (std::out_of_range& e) {
72607       {
72608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72609       };
72610     } catch (std::exception& e) {
72611       {
72612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72613       };
72614     } catch (...) {
72615       {
72616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72617       };
72618     }
72619   }
72620 }
72621
72622
72623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72624   float jresult ;
72625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72626   float arg2 ;
72627   float arg3 ;
72628   float result;
72629
72630   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72631   arg2 = (float)jarg2;
72632   arg3 = (float)jarg3;
72633   {
72634     try {
72635       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72636     } catch (std::out_of_range& e) {
72637       {
72638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72639       };
72640     } catch (std::exception& e) {
72641       {
72642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72643       };
72644     } catch (...) {
72645       {
72646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72647       };
72648     }
72649   }
72650   jresult = result;
72651   return jresult;
72652 }
72653
72654
72655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72656   float jresult ;
72657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72658   float arg2 ;
72659   float result;
72660
72661   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72662   arg2 = (float)jarg2;
72663   {
72664     try {
72665       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72666     } catch (std::out_of_range& e) {
72667       {
72668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72669       };
72670     } catch (std::exception& e) {
72671       {
72672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72673       };
72674     } catch (...) {
72675       {
72676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72677       };
72678     }
72679   }
72680   jresult = result;
72681   return jresult;
72682 }
72683
72684
72685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72686   float jresult ;
72687   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72688   unsigned int arg2 ;
72689   unsigned int *arg3 = 0 ;
72690   bool arg4 ;
72691   float result;
72692
72693   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72694   arg2 = (unsigned int)jarg2;
72695   arg3 = (unsigned int *)jarg3;
72696   arg4 = jarg4 ? true : false;
72697   {
72698     try {
72699       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72700     } catch (std::out_of_range& e) {
72701       {
72702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72703       };
72704     } catch (std::exception& e) {
72705       {
72706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72707       };
72708     } catch (...) {
72709       {
72710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72711       };
72712     }
72713   }
72714   jresult = result;
72715   return jresult;
72716 }
72717
72718
72719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72720   unsigned int jresult ;
72721   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72722   float arg2 ;
72723   bool arg3 ;
72724   unsigned int result;
72725
72726   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72727   arg2 = (float)jarg2;
72728   arg3 = jarg3 ? true : false;
72729   {
72730     try {
72731       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72732     } catch (std::out_of_range& e) {
72733       {
72734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72735       };
72736     } catch (std::exception& e) {
72737       {
72738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72739       };
72740     } catch (...) {
72741       {
72742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72743       };
72744     }
72745   }
72746   jresult = result;
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72752   unsigned int jresult ;
72753   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72754   unsigned int result;
72755
72756   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72757   {
72758     try {
72759       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72760     } catch (std::out_of_range& e) {
72761       {
72762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72763       };
72764     } catch (std::exception& e) {
72765       {
72766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72767       };
72768     } catch (...) {
72769       {
72770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72771       };
72772     }
72773   }
72774   jresult = result;
72775   return jresult;
72776 }
72777
72778
72779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72780   int jresult ;
72781   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72782   Dali::Toolkit::Ruler::RulerType result;
72783
72784   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72785   {
72786     try {
72787       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72788     } catch (std::out_of_range& e) {
72789       {
72790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72791       };
72792     } catch (std::exception& e) {
72793       {
72794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72795       };
72796     } catch (...) {
72797       {
72798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72799       };
72800     }
72801   }
72802   jresult = (int)result;
72803   return jresult;
72804 }
72805
72806
72807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72808   unsigned int jresult ;
72809   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72810   bool result;
72811
72812   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72813   {
72814     try {
72815       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72816     } catch (std::out_of_range& e) {
72817       {
72818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72819       };
72820     } catch (std::exception& e) {
72821       {
72822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72823       };
72824     } catch (...) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72827       };
72828     }
72829   }
72830   jresult = result;
72831   return jresult;
72832 }
72833
72834
72835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72836   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72837
72838   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72839   {
72840     try {
72841       (arg1)->Enable();
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72849       };
72850     } catch (...) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72853       };
72854     }
72855   }
72856 }
72857
72858
72859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72860   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72861
72862   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72863   {
72864     try {
72865       (arg1)->Disable();
72866     } catch (std::out_of_range& e) {
72867       {
72868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72869       };
72870     } catch (std::exception& e) {
72871       {
72872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72873       };
72874     } catch (...) {
72875       {
72876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72877       };
72878     }
72879   }
72880 }
72881
72882
72883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72884   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72885   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72886   Dali::Toolkit::RulerDomain *argp2 ;
72887
72888   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72889   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72890   if (!argp2) {
72891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72892     return ;
72893   }
72894   arg2 = *argp2;
72895   {
72896     try {
72897       (arg1)->SetDomain(arg2);
72898     } catch (std::out_of_range& e) {
72899       {
72900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72901       };
72902     } catch (std::exception& e) {
72903       {
72904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72905       };
72906     } catch (...) {
72907       {
72908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72909       };
72910     }
72911   }
72912 }
72913
72914
72915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72916   void * jresult ;
72917   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72918   Dali::Toolkit::RulerDomain *result = 0 ;
72919
72920   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72921   {
72922     try {
72923       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72924     } catch (std::out_of_range& e) {
72925       {
72926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72927       };
72928     } catch (std::exception& e) {
72929       {
72930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72931       };
72932     } catch (...) {
72933       {
72934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72935       };
72936     }
72937   }
72938   jresult = (void *)result;
72939   return jresult;
72940 }
72941
72942
72943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72944   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72945
72946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72947   {
72948     try {
72949       (arg1)->DisableDomain();
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72957       };
72958     } catch (...) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72961       };
72962     }
72963   }
72964 }
72965
72966
72967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72968   float jresult ;
72969   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72970   float arg2 ;
72971   float arg3 ;
72972   float arg4 ;
72973   float result;
72974
72975   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72976   arg2 = (float)jarg2;
72977   arg3 = (float)jarg3;
72978   arg4 = (float)jarg4;
72979   {
72980     try {
72981       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72982     } catch (std::out_of_range& e) {
72983       {
72984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72985       };
72986     } catch (std::exception& e) {
72987       {
72988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72989       };
72990     } catch (...) {
72991       {
72992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72993       };
72994     }
72995   }
72996   jresult = result;
72997   return jresult;
72998 }
72999
73000
73001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73002   float jresult ;
73003   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73004   float arg2 ;
73005   float arg3 ;
73006   float result;
73007
73008   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73009   arg2 = (float)jarg2;
73010   arg3 = (float)jarg3;
73011   {
73012     try {
73013       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73014     } catch (std::out_of_range& e) {
73015       {
73016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73017       };
73018     } catch (std::exception& e) {
73019       {
73020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73021       };
73022     } catch (...) {
73023       {
73024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73025       };
73026     }
73027   }
73028   jresult = result;
73029   return jresult;
73030 }
73031
73032
73033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73034   float jresult ;
73035   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73036   float arg2 ;
73037   float result;
73038
73039   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73040   arg2 = (float)jarg2;
73041   {
73042     try {
73043       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73044     } catch (std::out_of_range& e) {
73045       {
73046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73047       };
73048     } catch (std::exception& e) {
73049       {
73050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73051       };
73052     } catch (...) {
73053       {
73054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73055       };
73056     }
73057   }
73058   jresult = result;
73059   return jresult;
73060 }
73061
73062
73063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73064   float jresult ;
73065   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73066   float arg2 ;
73067   float arg3 ;
73068   float arg4 ;
73069   Dali::Toolkit::ClampState *arg5 = 0 ;
73070   float result;
73071
73072   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73073   arg2 = (float)jarg2;
73074   arg3 = (float)jarg3;
73075   arg4 = (float)jarg4;
73076   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73077   if (!arg5) {
73078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73079     return 0;
73080   }
73081   {
73082     try {
73083       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73084     } catch (std::out_of_range& e) {
73085       {
73086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73087       };
73088     } catch (std::exception& e) {
73089       {
73090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73091       };
73092     } catch (...) {
73093       {
73094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73095       };
73096     }
73097   }
73098   jresult = result;
73099   return jresult;
73100 }
73101
73102
73103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73104   float jresult ;
73105   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73106   float arg2 ;
73107   float arg3 ;
73108   float arg4 ;
73109   float arg5 ;
73110   float result;
73111
73112   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73113   arg2 = (float)jarg2;
73114   arg3 = (float)jarg3;
73115   arg4 = (float)jarg4;
73116   arg5 = (float)jarg5;
73117   {
73118     try {
73119       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73120     } catch (std::out_of_range& e) {
73121       {
73122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73123       };
73124     } catch (std::exception& e) {
73125       {
73126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (...) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73131       };
73132     }
73133   }
73134   jresult = result;
73135   return jresult;
73136 }
73137
73138
73139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73140   float jresult ;
73141   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73142   float arg2 ;
73143   float arg3 ;
73144   float arg4 ;
73145   float result;
73146
73147   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73148   arg2 = (float)jarg2;
73149   arg3 = (float)jarg3;
73150   arg4 = (float)jarg4;
73151   {
73152     try {
73153       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73154     } catch (std::out_of_range& e) {
73155       {
73156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73157       };
73158     } catch (std::exception& e) {
73159       {
73160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73161       };
73162     } catch (...) {
73163       {
73164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73165       };
73166     }
73167   }
73168   jresult = result;
73169   return jresult;
73170 }
73171
73172
73173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73174   float jresult ;
73175   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73176   float arg2 ;
73177   float arg3 ;
73178   float result;
73179
73180   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73181   arg2 = (float)jarg2;
73182   arg3 = (float)jarg3;
73183   {
73184     try {
73185       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73186     } catch (std::out_of_range& e) {
73187       {
73188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73189       };
73190     } catch (std::exception& e) {
73191       {
73192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73193       };
73194     } catch (...) {
73195       {
73196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73197       };
73198     }
73199   }
73200   jresult = result;
73201   return jresult;
73202 }
73203
73204
73205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73206   float jresult ;
73207   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73208   float arg2 ;
73209   float result;
73210
73211   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73212   arg2 = (float)jarg2;
73213   {
73214     try {
73215       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73216     } catch (std::out_of_range& e) {
73217       {
73218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73219       };
73220     } catch (std::exception& e) {
73221       {
73222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73223       };
73224     } catch (...) {
73225       {
73226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73227       };
73228     }
73229   }
73230   jresult = result;
73231   return jresult;
73232 }
73233
73234
73235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73236   float jresult ;
73237   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73238   float arg2 ;
73239   float arg3 ;
73240   float arg4 ;
73241   float arg5 ;
73242   Dali::Toolkit::ClampState *arg6 = 0 ;
73243   float result;
73244
73245   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73246   arg2 = (float)jarg2;
73247   arg3 = (float)jarg3;
73248   arg4 = (float)jarg4;
73249   arg5 = (float)jarg5;
73250   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73251   if (!arg6) {
73252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73253     return 0;
73254   }
73255   {
73256     try {
73257       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73258     } catch (std::out_of_range& e) {
73259       {
73260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73261       };
73262     } catch (std::exception& e) {
73263       {
73264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73265       };
73266     } catch (...) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73269       };
73270     }
73271   }
73272   jresult = result;
73273   return jresult;
73274 }
73275
73276
73277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73278   void * jresult ;
73279   Dali::Toolkit::DefaultRuler *result = 0 ;
73280
73281   {
73282     try {
73283       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (...) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73295       };
73296     }
73297   }
73298   jresult = (void *)result;
73299   return jresult;
73300 }
73301
73302
73303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73304   float jresult ;
73305   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73306   float arg2 ;
73307   float arg3 ;
73308   float result;
73309
73310   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73311   arg2 = (float)jarg2;
73312   arg3 = (float)jarg3;
73313   {
73314     try {
73315       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73316     } catch (std::out_of_range& e) {
73317       {
73318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (std::exception& e) {
73321       {
73322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (...) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73327       };
73328     }
73329   }
73330   jresult = result;
73331   return jresult;
73332 }
73333
73334
73335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73336   float jresult ;
73337   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73338   unsigned int arg2 ;
73339   unsigned int *arg3 = 0 ;
73340   bool arg4 ;
73341   float result;
73342
73343   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73344   arg2 = (unsigned int)jarg2;
73345   arg3 = (unsigned int *)jarg3;
73346   arg4 = jarg4 ? true : false;
73347   {
73348     try {
73349       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73350     } catch (std::out_of_range& e) {
73351       {
73352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73353       };
73354     } catch (std::exception& e) {
73355       {
73356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73357       };
73358     } catch (...) {
73359       {
73360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73361       };
73362     }
73363   }
73364   jresult = result;
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73370   unsigned int jresult ;
73371   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73372   float arg2 ;
73373   bool arg3 ;
73374   unsigned int result;
73375
73376   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73377   arg2 = (float)jarg2;
73378   arg3 = jarg3 ? true : false;
73379   {
73380     try {
73381       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73382     } catch (std::out_of_range& e) {
73383       {
73384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73385       };
73386     } catch (std::exception& e) {
73387       {
73388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (...) {
73391       {
73392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73393       };
73394     }
73395   }
73396   jresult = result;
73397   return jresult;
73398 }
73399
73400
73401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73402   unsigned int jresult ;
73403   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73404   unsigned int result;
73405
73406   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73407   {
73408     try {
73409       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73410     } catch (std::out_of_range& e) {
73411       {
73412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73413       };
73414     } catch (std::exception& e) {
73415       {
73416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73417       };
73418     } catch (...) {
73419       {
73420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73421       };
73422     }
73423   }
73424   jresult = result;
73425   return jresult;
73426 }
73427
73428
73429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73430   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73431
73432   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73433   {
73434     try {
73435       delete arg1;
73436     } catch (std::out_of_range& e) {
73437       {
73438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73439       };
73440     } catch (std::exception& e) {
73441       {
73442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73443       };
73444     } catch (...) {
73445       {
73446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73447       };
73448     }
73449   }
73450 }
73451
73452
73453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73454   void * jresult ;
73455   float arg1 ;
73456   Dali::Toolkit::FixedRuler *result = 0 ;
73457
73458   arg1 = (float)jarg1;
73459   {
73460     try {
73461       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73462     } catch (std::out_of_range& e) {
73463       {
73464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73465       };
73466     } catch (std::exception& e) {
73467       {
73468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (...) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73473       };
73474     }
73475   }
73476   jresult = (void *)result;
73477   return jresult;
73478 }
73479
73480
73481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73482   void * jresult ;
73483   Dali::Toolkit::FixedRuler *result = 0 ;
73484
73485   {
73486     try {
73487       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73488     } catch (std::out_of_range& e) {
73489       {
73490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73491       };
73492     } catch (std::exception& e) {
73493       {
73494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73495       };
73496     } catch (...) {
73497       {
73498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73499       };
73500     }
73501   }
73502   jresult = (void *)result;
73503   return jresult;
73504 }
73505
73506
73507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73508   float jresult ;
73509   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73510   float arg2 ;
73511   float arg3 ;
73512   float result;
73513
73514   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73515   arg2 = (float)jarg2;
73516   arg3 = (float)jarg3;
73517   {
73518     try {
73519       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73520     } catch (std::out_of_range& e) {
73521       {
73522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73523       };
73524     } catch (std::exception& e) {
73525       {
73526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (...) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73531       };
73532     }
73533   }
73534   jresult = result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73540   float jresult ;
73541   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73542   unsigned int arg2 ;
73543   unsigned int *arg3 = 0 ;
73544   bool arg4 ;
73545   float result;
73546
73547   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73548   arg2 = (unsigned int)jarg2;
73549   arg3 = (unsigned int *)jarg3;
73550   arg4 = jarg4 ? true : false;
73551   {
73552     try {
73553       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73554     } catch (std::out_of_range& e) {
73555       {
73556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73557       };
73558     } catch (std::exception& e) {
73559       {
73560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73561       };
73562     } catch (...) {
73563       {
73564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73565       };
73566     }
73567   }
73568   jresult = result;
73569   return jresult;
73570 }
73571
73572
73573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73574   unsigned int jresult ;
73575   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73576   float arg2 ;
73577   bool arg3 ;
73578   unsigned int result;
73579
73580   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73581   arg2 = (float)jarg2;
73582   arg3 = jarg3 ? true : false;
73583   {
73584     try {
73585       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73586     } catch (std::out_of_range& e) {
73587       {
73588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73589       };
73590     } catch (std::exception& e) {
73591       {
73592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73593       };
73594     } catch (...) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73597       };
73598     }
73599   }
73600   jresult = result;
73601   return jresult;
73602 }
73603
73604
73605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73606   unsigned int jresult ;
73607   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73608   unsigned int result;
73609
73610   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73611   {
73612     try {
73613       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73614     } catch (std::out_of_range& e) {
73615       {
73616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73617       };
73618     } catch (std::exception& e) {
73619       {
73620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73621       };
73622     } catch (...) {
73623       {
73624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73625       };
73626     }
73627   }
73628   jresult = result;
73629   return jresult;
73630 }
73631
73632
73633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73634   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73635
73636   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73637   {
73638     try {
73639       delete arg1;
73640     } catch (std::out_of_range& e) {
73641       {
73642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73643       };
73644     } catch (std::exception& e) {
73645       {
73646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73647       };
73648     } catch (...) {
73649       {
73650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73651       };
73652     }
73653   }
73654 }
73655
73656
73657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73658   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73659   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73660
73661   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73662   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73663   if (arg1) (arg1)->scale = *arg2;
73664 }
73665
73666
73667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73668   void * jresult ;
73669   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73670   Dali::Toolkit::ClampState2D *result = 0 ;
73671
73672   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73673   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73674   jresult = (void *)result;
73675   return jresult;
73676 }
73677
73678
73679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73680   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73681   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73682
73683   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73684   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73685   if (arg1) (arg1)->position = *arg2;
73686 }
73687
73688
73689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73690   void * jresult ;
73691   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73692   Dali::Toolkit::ClampState2D *result = 0 ;
73693
73694   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73695   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73696   jresult = (void *)result;
73697   return jresult;
73698 }
73699
73700
73701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73702   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73703   Dali::Toolkit::ClampState arg2 ;
73704
73705   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73706   arg2 = (Dali::Toolkit::ClampState)jarg2;
73707   if (arg1) (arg1)->rotation = arg2;
73708 }
73709
73710
73711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73712   int jresult ;
73713   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73714   Dali::Toolkit::ClampState result;
73715
73716   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73717   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73718   jresult = (int)result;
73719   return jresult;
73720 }
73721
73722
73723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73724   void * jresult ;
73725   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73726
73727   {
73728     try {
73729       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73730     } catch (std::out_of_range& e) {
73731       {
73732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73733       };
73734     } catch (std::exception& e) {
73735       {
73736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73737       };
73738     } catch (...) {
73739       {
73740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73741       };
73742     }
73743   }
73744   jresult = (void *)result;
73745   return jresult;
73746 }
73747
73748
73749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73750   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73751
73752   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73753   {
73754     try {
73755       delete arg1;
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73763       };
73764     } catch (...) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73767       };
73768     }
73769   }
73770 }
73771
73772
73773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73774   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73775   Dali::Toolkit::SnapType arg2 ;
73776
73777   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73778   arg2 = (Dali::Toolkit::SnapType)jarg2;
73779   if (arg1) (arg1)->type = arg2;
73780 }
73781
73782
73783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73784   int jresult ;
73785   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73786   Dali::Toolkit::SnapType result;
73787
73788   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73789   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73790   jresult = (int)result;
73791   return jresult;
73792 }
73793
73794
73795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73796   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73797   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73798
73799   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73800   arg2 = (Dali::Vector2 *)jarg2;
73801   if (arg1) (arg1)->position = *arg2;
73802 }
73803
73804
73805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73806   void * jresult ;
73807   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73808   Dali::Vector2 *result = 0 ;
73809
73810   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73811   result = (Dali::Vector2 *)& ((arg1)->position);
73812   jresult = (void *)result;
73813   return jresult;
73814 }
73815
73816
73817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73818   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73819   float arg2 ;
73820
73821   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73822   arg2 = (float)jarg2;
73823   if (arg1) (arg1)->duration = arg2;
73824 }
73825
73826
73827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73828   float jresult ;
73829   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73830   float result;
73831
73832   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73833   result = (float) ((arg1)->duration);
73834   jresult = result;
73835   return jresult;
73836 }
73837
73838
73839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73840   void * jresult ;
73841   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73842
73843   {
73844     try {
73845       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73846     } catch (std::out_of_range& e) {
73847       {
73848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73849       };
73850     } catch (std::exception& e) {
73851       {
73852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73853       };
73854     } catch (...) {
73855       {
73856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73857       };
73858     }
73859   }
73860   jresult = (void *)result;
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73866   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73867
73868   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73869   {
73870     try {
73871       delete arg1;
73872     } catch (std::out_of_range& e) {
73873       {
73874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73875       };
73876     } catch (std::exception& e) {
73877       {
73878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73879       };
73880     } catch (...) {
73881       {
73882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73883       };
73884     }
73885   }
73886 }
73887
73888
73889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73890   int jresult ;
73891   int result;
73892
73893   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73894   jresult = (int)result;
73895   return jresult;
73896 }
73897
73898
73899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73900   int jresult ;
73901   int result;
73902
73903   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73904   jresult = (int)result;
73905   return jresult;
73906 }
73907
73908
73909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73910   int jresult ;
73911   int result;
73912
73913   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73914   jresult = (int)result;
73915   return jresult;
73916 }
73917
73918
73919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73920   int jresult ;
73921   int result;
73922
73923   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73924   jresult = (int)result;
73925   return jresult;
73926 }
73927
73928
73929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
73930   int jresult ;
73931   int result;
73932
73933   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
73934   jresult = (int)result;
73935   return jresult;
73936 }
73937
73938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
73939   int jresult ;
73940   int result;
73941
73942   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73943   jresult = (int)result;
73944   return jresult;
73945 }
73946
73947
73948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73949   int jresult ;
73950   int result;
73951
73952   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73953   jresult = (int)result;
73954   return jresult;
73955 }
73956
73957
73958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73959   int jresult ;
73960   int result;
73961
73962   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73963   jresult = (int)result;
73964   return jresult;
73965 }
73966
73967
73968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73969   int jresult ;
73970   int result;
73971
73972   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73973   jresult = (int)result;
73974   return jresult;
73975 }
73976
73977
73978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73979   int jresult ;
73980   int result;
73981
73982   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73983   jresult = (int)result;
73984   return jresult;
73985 }
73986
73987
73988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73989   int jresult ;
73990   int result;
73991
73992   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73993   jresult = (int)result;
73994   return jresult;
73995 }
73996
73997
73998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73999   int jresult ;
74000   int result;
74001
74002   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74003   jresult = (int)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74009   int jresult ;
74010   int result;
74011
74012   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74013   jresult = (int)result;
74014   return jresult;
74015 }
74016
74017
74018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74019   int jresult ;
74020   int result;
74021
74022   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74023   jresult = (int)result;
74024   return jresult;
74025 }
74026
74027
74028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74029   int jresult ;
74030   int result;
74031
74032   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74033   jresult = (int)result;
74034   return jresult;
74035 }
74036
74037
74038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74039   int jresult ;
74040   int result;
74041
74042   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74043   jresult = (int)result;
74044   return jresult;
74045 }
74046
74047
74048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74049   int jresult ;
74050   int result;
74051
74052   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74053   jresult = (int)result;
74054   return jresult;
74055 }
74056
74057
74058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74059   int jresult ;
74060   int result;
74061
74062   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74063   jresult = (int)result;
74064   return jresult;
74065 }
74066
74067
74068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74069   int jresult ;
74070   int result;
74071
74072   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74073   jresult = (int)result;
74074   return jresult;
74075 }
74076
74077
74078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74079   int jresult ;
74080   int result;
74081
74082   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74083   jresult = (int)result;
74084   return jresult;
74085 }
74086
74087
74088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74089   int jresult ;
74090   int result;
74091
74092   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74093   jresult = (int)result;
74094   return jresult;
74095 }
74096
74097
74098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74099   int jresult ;
74100   int result;
74101
74102   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74103   jresult = (int)result;
74104   return jresult;
74105 }
74106
74107
74108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74109   int jresult ;
74110   int result;
74111
74112   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74113   jresult = (int)result;
74114   return jresult;
74115 }
74116
74117
74118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74119   int jresult ;
74120   int result;
74121
74122   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74123   jresult = (int)result;
74124   return jresult;
74125 }
74126
74127
74128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74129   int jresult ;
74130   int result;
74131
74132   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74133   jresult = (int)result;
74134   return jresult;
74135 }
74136
74137
74138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74139   int jresult ;
74140   int result;
74141
74142   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74143   jresult = (int)result;
74144   return jresult;
74145 }
74146
74147
74148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74149   void * jresult ;
74150   Dali::Toolkit::ScrollView::Property *result = 0 ;
74151
74152   {
74153     try {
74154       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74155     } catch (std::out_of_range& e) {
74156       {
74157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74158       };
74159     } catch (std::exception& e) {
74160       {
74161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74162       };
74163     } catch (...) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74166       };
74167     }
74168   }
74169   jresult = (void *)result;
74170   return jresult;
74171 }
74172
74173
74174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74175   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74176
74177   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74178   {
74179     try {
74180       delete arg1;
74181     } catch (std::out_of_range& e) {
74182       {
74183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74184       };
74185     } catch (std::exception& e) {
74186       {
74187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74188       };
74189     } catch (...) {
74190       {
74191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74192       };
74193     }
74194   }
74195 }
74196
74197
74198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74199   void * jresult ;
74200   Dali::Toolkit::ScrollView *result = 0 ;
74201
74202   {
74203     try {
74204       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74205     } catch (std::out_of_range& e) {
74206       {
74207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74208       };
74209     } catch (std::exception& e) {
74210       {
74211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74212       };
74213     } catch (...) {
74214       {
74215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74216       };
74217     }
74218   }
74219   jresult = (void *)result;
74220   return jresult;
74221 }
74222
74223
74224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74225   void * jresult ;
74226   Dali::Toolkit::ScrollView *arg1 = 0 ;
74227   Dali::Toolkit::ScrollView *result = 0 ;
74228
74229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74230   if (!arg1) {
74231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74232     return 0;
74233   }
74234   {
74235     try {
74236       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74237     } catch (std::out_of_range& e) {
74238       {
74239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74240       };
74241     } catch (std::exception& e) {
74242       {
74243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (...) {
74246       {
74247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74248       };
74249     }
74250   }
74251   jresult = (void *)result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74257   void * jresult ;
74258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74259   Dali::Toolkit::ScrollView *arg2 = 0 ;
74260   Dali::Toolkit::ScrollView *result = 0 ;
74261
74262   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74263   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74264   if (!arg2) {
74265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74266     return 0;
74267   }
74268   {
74269     try {
74270       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74271     } catch (std::out_of_range& e) {
74272       {
74273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (std::exception& e) {
74276       {
74277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74278       };
74279     } catch (...) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74282       };
74283     }
74284   }
74285   jresult = (void *)result;
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74291   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74292
74293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74294   {
74295     try {
74296       delete arg1;
74297     } catch (std::out_of_range& e) {
74298       {
74299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74300       };
74301     } catch (std::exception& e) {
74302       {
74303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74304       };
74305     } catch (...) {
74306       {
74307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74308       };
74309     }
74310   }
74311 }
74312
74313
74314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74315   void * jresult ;
74316   Dali::Toolkit::ScrollView result;
74317
74318   {
74319     try {
74320       result = Dali::Toolkit::ScrollView::New();
74321     } catch (std::out_of_range& e) {
74322       {
74323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74324       };
74325     } catch (std::exception& e) {
74326       {
74327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74328       };
74329     } catch (...) {
74330       {
74331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74332       };
74333     }
74334   }
74335   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74336   return jresult;
74337 }
74338
74339
74340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74341   void * jresult ;
74342   Dali::BaseHandle arg1 ;
74343   Dali::BaseHandle *argp1 ;
74344   Dali::Toolkit::ScrollView result;
74345
74346   argp1 = (Dali::BaseHandle *)jarg1;
74347   if (!argp1) {
74348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74349     return 0;
74350   }
74351   arg1 = *argp1;
74352   {
74353     try {
74354       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74362       };
74363     } catch (...) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74366       };
74367     }
74368   }
74369   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74375   void * jresult ;
74376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74377   Dali::AlphaFunction result;
74378
74379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74380   {
74381     try {
74382       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74383     } catch (std::out_of_range& e) {
74384       {
74385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74386       };
74387     } catch (std::exception& e) {
74388       {
74389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74390       };
74391     } catch (...) {
74392       {
74393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74394       };
74395     }
74396   }
74397   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74398   return jresult;
74399 }
74400
74401
74402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74404   Dali::AlphaFunction arg2 ;
74405   Dali::AlphaFunction *argp2 ;
74406
74407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74408   argp2 = (Dali::AlphaFunction *)jarg2;
74409   if (!argp2) {
74410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74411     return ;
74412   }
74413   arg2 = *argp2;
74414   {
74415     try {
74416       (arg1)->SetScrollSnapAlphaFunction(arg2);
74417     } catch (std::out_of_range& e) {
74418       {
74419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74420       };
74421     } catch (std::exception& e) {
74422       {
74423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (...) {
74426       {
74427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74428       };
74429     }
74430   }
74431 }
74432
74433
74434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74435   void * jresult ;
74436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74437   Dali::AlphaFunction result;
74438
74439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74440   {
74441     try {
74442       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (...) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74454       };
74455     }
74456   }
74457   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74458   return jresult;
74459 }
74460
74461
74462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74463   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74464   Dali::AlphaFunction arg2 ;
74465   Dali::AlphaFunction *argp2 ;
74466
74467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74468   argp2 = (Dali::AlphaFunction *)jarg2;
74469   if (!argp2) {
74470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74471     return ;
74472   }
74473   arg2 = *argp2;
74474   {
74475     try {
74476       (arg1)->SetScrollFlickAlphaFunction(arg2);
74477     } catch (std::out_of_range& e) {
74478       {
74479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (std::exception& e) {
74482       {
74483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74484       };
74485     } catch (...) {
74486       {
74487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74488       };
74489     }
74490   }
74491 }
74492
74493
74494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74495   float jresult ;
74496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74497   float result;
74498
74499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74500   {
74501     try {
74502       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74510       };
74511     } catch (...) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74514       };
74515     }
74516   }
74517   jresult = result;
74518   return jresult;
74519 }
74520
74521
74522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74523   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74524   float arg2 ;
74525
74526   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74527   arg2 = (float)jarg2;
74528   {
74529     try {
74530       (arg1)->SetScrollSnapDuration(arg2);
74531     } catch (std::out_of_range& e) {
74532       {
74533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74534       };
74535     } catch (std::exception& e) {
74536       {
74537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74538       };
74539     } catch (...) {
74540       {
74541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74542       };
74543     }
74544   }
74545 }
74546
74547
74548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74549   float jresult ;
74550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74551   float result;
74552
74553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74554   {
74555     try {
74556       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74557     } catch (std::out_of_range& e) {
74558       {
74559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74560       };
74561     } catch (std::exception& e) {
74562       {
74563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74568       };
74569     }
74570   }
74571   jresult = result;
74572   return jresult;
74573 }
74574
74575
74576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74577   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74578   float arg2 ;
74579
74580   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74581   arg2 = (float)jarg2;
74582   {
74583     try {
74584       (arg1)->SetScrollFlickDuration(arg2);
74585     } catch (std::out_of_range& e) {
74586       {
74587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74588       };
74589     } catch (std::exception& e) {
74590       {
74591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74592       };
74593     } catch (...) {
74594       {
74595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74596       };
74597     }
74598   }
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74604   Dali::Toolkit::RulerPtr arg2 ;
74605   Dali::Toolkit::RulerPtr *argp2 ;
74606
74607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74608   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74609   if (!argp2) {
74610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74611     return ;
74612   }
74613   arg2 = *argp2;
74614   {
74615     try {
74616       (arg1)->SetRulerX(arg2);
74617     } catch (std::out_of_range& e) {
74618       {
74619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74620       };
74621     } catch (std::exception& e) {
74622       {
74623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74624       };
74625     } catch (...) {
74626       {
74627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74628       };
74629     }
74630   }
74631 }
74632
74633
74634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74636   Dali::Toolkit::RulerPtr arg2 ;
74637   Dali::Toolkit::RulerPtr *argp2 ;
74638
74639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74640   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74641   if (!argp2) {
74642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74643     return ;
74644   }
74645   arg2 = *argp2;
74646   {
74647     try {
74648       (arg1)->SetRulerY(arg2);
74649     } catch (std::out_of_range& e) {
74650       {
74651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74652       };
74653     } catch (std::exception& e) {
74654       {
74655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74656       };
74657     } catch (...) {
74658       {
74659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74660       };
74661     }
74662   }
74663 }
74664
74665
74666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74668   bool arg2 ;
74669
74670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74671   arg2 = jarg2 ? true : false;
74672   {
74673     try {
74674       (arg1)->SetScrollSensitive(arg2);
74675     } catch (std::out_of_range& e) {
74676       {
74677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74678       };
74679     } catch (std::exception& e) {
74680       {
74681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74682       };
74683     } catch (...) {
74684       {
74685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74686       };
74687     }
74688   }
74689 }
74690
74691
74692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74694   float arg2 ;
74695   float arg3 ;
74696
74697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74698   arg2 = (float)jarg2;
74699   arg3 = (float)jarg3;
74700   {
74701     try {
74702       (arg1)->SetMaxOvershoot(arg2,arg3);
74703     } catch (std::out_of_range& e) {
74704       {
74705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74706       };
74707     } catch (std::exception& e) {
74708       {
74709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74710       };
74711     } catch (...) {
74712       {
74713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74714       };
74715     }
74716   }
74717 }
74718
74719
74720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74722   Dali::AlphaFunction arg2 ;
74723   Dali::AlphaFunction *argp2 ;
74724
74725   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74726   argp2 = (Dali::AlphaFunction *)jarg2;
74727   if (!argp2) {
74728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74729     return ;
74730   }
74731   arg2 = *argp2;
74732   {
74733     try {
74734       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74735     } catch (std::out_of_range& e) {
74736       {
74737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74738       };
74739     } catch (std::exception& e) {
74740       {
74741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74742       };
74743     } catch (...) {
74744       {
74745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74746       };
74747     }
74748   }
74749 }
74750
74751
74752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74754   float arg2 ;
74755
74756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74757   arg2 = (float)jarg2;
74758   {
74759     try {
74760       (arg1)->SetSnapOvershootDuration(arg2);
74761     } catch (std::out_of_range& e) {
74762       {
74763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74764       };
74765     } catch (std::exception& e) {
74766       {
74767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74768       };
74769     } catch (...) {
74770       {
74771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74772       };
74773     }
74774   }
74775 }
74776
74777
74778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74780   bool arg2 ;
74781
74782   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74783   arg2 = jarg2 ? true : false;
74784   {
74785     try {
74786       (arg1)->SetActorAutoSnap(arg2);
74787     } catch (std::out_of_range& e) {
74788       {
74789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74790       };
74791     } catch (std::exception& e) {
74792       {
74793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74794       };
74795     } catch (...) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74798       };
74799     }
74800   }
74801 }
74802
74803
74804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74806   bool arg2 ;
74807
74808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74809   arg2 = jarg2 ? true : false;
74810   {
74811     try {
74812       (arg1)->SetWrapMode(arg2);
74813     } catch (std::out_of_range& e) {
74814       {
74815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74816       };
74817     } catch (std::exception& e) {
74818       {
74819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74824       };
74825     }
74826   }
74827 }
74828
74829
74830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74831   int jresult ;
74832   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74833   int result;
74834
74835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74836   {
74837     try {
74838       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (...) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74850       };
74851     }
74852   }
74853   jresult = result;
74854   return jresult;
74855 }
74856
74857
74858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74860   int arg2 ;
74861
74862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74863   arg2 = (int)jarg2;
74864   {
74865     try {
74866       (arg1)->SetScrollUpdateDistance(arg2);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74878       };
74879     }
74880   }
74881 }
74882
74883
74884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74885   unsigned int jresult ;
74886   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74887   bool result;
74888
74889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74890   {
74891     try {
74892       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74893     } catch (std::out_of_range& e) {
74894       {
74895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74896       };
74897     } catch (std::exception& e) {
74898       {
74899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74900       };
74901     } catch (...) {
74902       {
74903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74904       };
74905     }
74906   }
74907   jresult = result;
74908   return jresult;
74909 }
74910
74911
74912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74913   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74914   bool arg2 ;
74915
74916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74917   arg2 = jarg2 ? true : false;
74918   {
74919     try {
74920       (arg1)->SetAxisAutoLock(arg2);
74921     } catch (std::out_of_range& e) {
74922       {
74923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74924       };
74925     } catch (std::exception& e) {
74926       {
74927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74928       };
74929     } catch (...) {
74930       {
74931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74932       };
74933     }
74934   }
74935 }
74936
74937
74938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74939   float jresult ;
74940   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74941   float result;
74942
74943   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74944   {
74945     try {
74946       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74947     } catch (std::out_of_range& e) {
74948       {
74949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (std::exception& e) {
74952       {
74953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961   jresult = result;
74962   return jresult;
74963 }
74964
74965
74966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74967   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74968   float arg2 ;
74969
74970   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74971   arg2 = (float)jarg2;
74972   {
74973     try {
74974       (arg1)->SetAxisAutoLockGradient(arg2);
74975     } catch (std::out_of_range& e) {
74976       {
74977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74978       };
74979     } catch (std::exception& e) {
74980       {
74981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74982       };
74983     } catch (...) {
74984       {
74985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74986       };
74987     }
74988   }
74989 }
74990
74991
74992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74993   float jresult ;
74994   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74995   float result;
74996
74997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74998   {
74999     try {
75000       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75001     } catch (std::out_of_range& e) {
75002       {
75003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75004       };
75005     } catch (std::exception& e) {
75006       {
75007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75008       };
75009     } catch (...) {
75010       {
75011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75012       };
75013     }
75014   }
75015   jresult = result;
75016   return jresult;
75017 }
75018
75019
75020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75021   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75022   float arg2 ;
75023
75024   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75025   arg2 = (float)jarg2;
75026   {
75027     try {
75028       (arg1)->SetFrictionCoefficient(arg2);
75029     } catch (std::out_of_range& e) {
75030       {
75031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75032       };
75033     } catch (std::exception& e) {
75034       {
75035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75036       };
75037     } catch (...) {
75038       {
75039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75040       };
75041     }
75042   }
75043 }
75044
75045
75046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75047   float jresult ;
75048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75049   float result;
75050
75051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75052   {
75053     try {
75054       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75055     } catch (std::out_of_range& e) {
75056       {
75057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75058       };
75059     } catch (std::exception& e) {
75060       {
75061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75062       };
75063     } catch (...) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75066       };
75067     }
75068   }
75069   jresult = result;
75070   return jresult;
75071 }
75072
75073
75074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75075   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75076   float arg2 ;
75077
75078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75079   arg2 = (float)jarg2;
75080   {
75081     try {
75082       (arg1)->SetFlickSpeedCoefficient(arg2);
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75090       };
75091     } catch (...) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75094       };
75095     }
75096   }
75097 }
75098
75099
75100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75101   void * jresult ;
75102   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75103   Dali::Vector2 result;
75104
75105   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75106   {
75107     try {
75108       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75109     } catch (std::out_of_range& e) {
75110       {
75111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75112       };
75113     } catch (std::exception& e) {
75114       {
75115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75116       };
75117     } catch (...) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75120       };
75121     }
75122   }
75123   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75124   return jresult;
75125 }
75126
75127
75128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75130   Dali::Vector2 *arg2 = 0 ;
75131
75132   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75133   arg2 = (Dali::Vector2 *)jarg2;
75134   if (!arg2) {
75135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75136     return ;
75137   }
75138   {
75139     try {
75140       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75141     } catch (std::out_of_range& e) {
75142       {
75143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75144       };
75145     } catch (std::exception& e) {
75146       {
75147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75148       };
75149     } catch (...) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75152       };
75153     }
75154   }
75155 }
75156
75157
75158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75159   float jresult ;
75160   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75161   float result;
75162
75163   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75164   {
75165     try {
75166       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75178       };
75179     }
75180   }
75181   jresult = result;
75182   return jresult;
75183 }
75184
75185
75186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75187   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75188   float arg2 ;
75189
75190   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75191   arg2 = (float)jarg2;
75192   {
75193     try {
75194       (arg1)->SetMinimumSpeedForFlick(arg2);
75195     } catch (std::out_of_range& e) {
75196       {
75197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75198       };
75199     } catch (std::exception& e) {
75200       {
75201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75206       };
75207     }
75208   }
75209 }
75210
75211
75212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75213   float jresult ;
75214   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75215   float result;
75216
75217   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75218   {
75219     try {
75220       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
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 (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235   jresult = result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75242   float arg2 ;
75243
75244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75245   arg2 = (float)jarg2;
75246   {
75247     try {
75248       (arg1)->SetMaxFlickSpeed(arg2);
75249     } catch (std::out_of_range& e) {
75250       {
75251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75252       };
75253     } catch (std::exception& e) {
75254       {
75255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75256       };
75257     } catch (...) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75260       };
75261     }
75262   }
75263 }
75264
75265
75266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75267   void * jresult ;
75268   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75269   Dali::Vector2 result;
75270
75271   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75272   {
75273     try {
75274       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75282       };
75283     } catch (...) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75286       };
75287     }
75288   }
75289   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75290   return jresult;
75291 }
75292
75293
75294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75295   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75296   Dali::Vector2 arg2 ;
75297   Dali::Vector2 *argp2 ;
75298
75299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75300   argp2 = (Dali::Vector2 *)jarg2;
75301   if (!argp2) {
75302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75303     return ;
75304   }
75305   arg2 = *argp2;
75306   {
75307     try {
75308       (arg1)->SetWheelScrollDistanceStep(arg2);
75309     } catch (std::out_of_range& e) {
75310       {
75311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75312       };
75313     } catch (std::exception& e) {
75314       {
75315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75316       };
75317     } catch (...) {
75318       {
75319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75320       };
75321     }
75322   }
75323 }
75324
75325
75326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75327   void * jresult ;
75328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75329   Dali::Vector2 result;
75330
75331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75332   {
75333     try {
75334       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75346       };
75347     }
75348   }
75349   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75350   return jresult;
75351 }
75352
75353
75354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75355   unsigned int jresult ;
75356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75357   unsigned int result;
75358
75359   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75360   {
75361     try {
75362       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75363     } catch (std::out_of_range& e) {
75364       {
75365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75366       };
75367     } catch (std::exception& e) {
75368       {
75369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75370       };
75371     } catch (...) {
75372       {
75373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75374       };
75375     }
75376   }
75377   jresult = result;
75378   return jresult;
75379 }
75380
75381
75382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75384   Dali::Vector2 *arg2 = 0 ;
75385
75386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75387   arg2 = (Dali::Vector2 *)jarg2;
75388   if (!arg2) {
75389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75390     return ;
75391   }
75392   {
75393     try {
75394       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75395     } catch (std::out_of_range& e) {
75396       {
75397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75398       };
75399     } catch (std::exception& e) {
75400       {
75401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75402       };
75403     } catch (...) {
75404       {
75405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75406       };
75407     }
75408   }
75409 }
75410
75411
75412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75414   Dali::Vector2 *arg2 = 0 ;
75415   float arg3 ;
75416
75417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75418   arg2 = (Dali::Vector2 *)jarg2;
75419   if (!arg2) {
75420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75421     return ;
75422   }
75423   arg3 = (float)jarg3;
75424   {
75425     try {
75426       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75427     } catch (std::out_of_range& e) {
75428       {
75429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75430       };
75431     } catch (std::exception& e) {
75432       {
75433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75434       };
75435     } catch (...) {
75436       {
75437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75438       };
75439     }
75440   }
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75446   Dali::Vector2 *arg2 = 0 ;
75447   float arg3 ;
75448   Dali::AlphaFunction arg4 ;
75449   Dali::AlphaFunction *argp4 ;
75450
75451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75452   arg2 = (Dali::Vector2 *)jarg2;
75453   if (!arg2) {
75454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75455     return ;
75456   }
75457   arg3 = (float)jarg3;
75458   argp4 = (Dali::AlphaFunction *)jarg4;
75459   if (!argp4) {
75460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75461     return ;
75462   }
75463   arg4 = *argp4;
75464   {
75465     try {
75466       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75467     } catch (std::out_of_range& e) {
75468       {
75469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75470       };
75471     } catch (std::exception& e) {
75472       {
75473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75478       };
75479     }
75480   }
75481 }
75482
75483
75484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75485   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75486   Dali::Vector2 *arg2 = 0 ;
75487   float arg3 ;
75488   Dali::Toolkit::DirectionBias arg4 ;
75489   Dali::Toolkit::DirectionBias arg5 ;
75490
75491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75492   arg2 = (Dali::Vector2 *)jarg2;
75493   if (!arg2) {
75494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75495     return ;
75496   }
75497   arg3 = (float)jarg3;
75498   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75499   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75500   {
75501     try {
75502       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75503     } catch (std::out_of_range& e) {
75504       {
75505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75506       };
75507     } catch (std::exception& e) {
75508       {
75509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75510       };
75511     } catch (...) {
75512       {
75513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75514       };
75515     }
75516   }
75517 }
75518
75519
75520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75522   Dali::Vector2 *arg2 = 0 ;
75523   float arg3 ;
75524   Dali::AlphaFunction arg4 ;
75525   Dali::Toolkit::DirectionBias arg5 ;
75526   Dali::Toolkit::DirectionBias arg6 ;
75527   Dali::AlphaFunction *argp4 ;
75528
75529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75530   arg2 = (Dali::Vector2 *)jarg2;
75531   if (!arg2) {
75532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75533     return ;
75534   }
75535   arg3 = (float)jarg3;
75536   argp4 = (Dali::AlphaFunction *)jarg4;
75537   if (!argp4) {
75538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75539     return ;
75540   }
75541   arg4 = *argp4;
75542   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75543   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75544   {
75545     try {
75546       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75547     } catch (std::out_of_range& e) {
75548       {
75549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75550       };
75551     } catch (std::exception& e) {
75552       {
75553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75554       };
75555     } catch (...) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75558       };
75559     }
75560   }
75561 }
75562
75563
75564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75565   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75566   unsigned int arg2 ;
75567
75568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75569   arg2 = (unsigned int)jarg2;
75570   {
75571     try {
75572       (arg1)->ScrollTo(arg2);
75573     } catch (std::out_of_range& e) {
75574       {
75575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75576       };
75577     } catch (std::exception& e) {
75578       {
75579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75580       };
75581     } catch (...) {
75582       {
75583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75584       };
75585     }
75586   }
75587 }
75588
75589
75590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75592   unsigned int arg2 ;
75593   float arg3 ;
75594
75595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75596   arg2 = (unsigned int)jarg2;
75597   arg3 = (float)jarg3;
75598   {
75599     try {
75600       (arg1)->ScrollTo(arg2,arg3);
75601     } catch (std::out_of_range& e) {
75602       {
75603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75604       };
75605     } catch (std::exception& e) {
75606       {
75607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75608       };
75609     } catch (...) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75612       };
75613     }
75614   }
75615 }
75616
75617
75618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75619   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75620   unsigned int arg2 ;
75621   float arg3 ;
75622   Dali::Toolkit::DirectionBias arg4 ;
75623
75624   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75625   arg2 = (unsigned int)jarg2;
75626   arg3 = (float)jarg3;
75627   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75628   {
75629     try {
75630       (arg1)->ScrollTo(arg2,arg3,arg4);
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75642       };
75643     }
75644   }
75645 }
75646
75647
75648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75650   Dali::Actor *arg2 = 0 ;
75651
75652   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75653   arg2 = (Dali::Actor *)jarg2;
75654   if (!arg2) {
75655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75656     return ;
75657   }
75658   {
75659     try {
75660       (arg1)->ScrollTo(*arg2);
75661     } catch (std::out_of_range& e) {
75662       {
75663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (std::exception& e) {
75666       {
75667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75668       };
75669     } catch (...) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75672       };
75673     }
75674   }
75675 }
75676
75677
75678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75680   Dali::Actor *arg2 = 0 ;
75681   float arg3 ;
75682
75683   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75684   arg2 = (Dali::Actor *)jarg2;
75685   if (!arg2) {
75686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75687     return ;
75688   }
75689   arg3 = (float)jarg3;
75690   {
75691     try {
75692       (arg1)->ScrollTo(*arg2,arg3);
75693     } catch (std::out_of_range& e) {
75694       {
75695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75696       };
75697     } catch (std::exception& e) {
75698       {
75699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (...) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75704       };
75705     }
75706   }
75707 }
75708
75709
75710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75711   unsigned int jresult ;
75712   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75713   bool result;
75714
75715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75716   {
75717     try {
75718       result = (bool)(arg1)->ScrollToSnapPoint();
75719     } catch (std::out_of_range& e) {
75720       {
75721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75722       };
75723     } catch (std::exception& e) {
75724       {
75725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75726       };
75727     } catch (...) {
75728       {
75729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75730       };
75731     }
75732   }
75733   jresult = result;
75734   return jresult;
75735 }
75736
75737
75738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75740   Dali::Constraint arg2 ;
75741   Dali::Constraint *argp2 ;
75742
75743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75744   argp2 = (Dali::Constraint *)jarg2;
75745   if (!argp2) {
75746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75747     return ;
75748   }
75749   arg2 = *argp2;
75750   {
75751     try {
75752       (arg1)->ApplyConstraintToChildren(arg2);
75753     } catch (std::out_of_range& e) {
75754       {
75755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (std::exception& e) {
75758       {
75759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75760       };
75761     } catch (...) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75764       };
75765     }
75766   }
75767 }
75768
75769
75770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75772
75773   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75774   {
75775     try {
75776       (arg1)->RemoveConstraintsFromChildren();
75777     } catch (std::out_of_range& e) {
75778       {
75779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75780       };
75781     } catch (std::exception& e) {
75782       {
75783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75784       };
75785     } catch (...) {
75786       {
75787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75788       };
75789     }
75790   }
75791 }
75792
75793
75794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75796   Dali::Toolkit::ScrollViewEffect arg2 ;
75797   Dali::Toolkit::ScrollViewEffect *argp2 ;
75798
75799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75800   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75801   if (!argp2) {
75802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75803     return ;
75804   }
75805   arg2 = *argp2;
75806   {
75807     try {
75808       (arg1)->ApplyEffect(arg2);
75809     } catch (std::out_of_range& e) {
75810       {
75811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (std::exception& e) {
75814       {
75815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75816       };
75817     } catch (...) {
75818       {
75819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75820       };
75821     }
75822   }
75823 }
75824
75825
75826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75828   Dali::Toolkit::ScrollViewEffect arg2 ;
75829   Dali::Toolkit::ScrollViewEffect *argp2 ;
75830
75831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75832   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75833   if (!argp2) {
75834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75835     return ;
75836   }
75837   arg2 = *argp2;
75838   {
75839     try {
75840       (arg1)->RemoveEffect(arg2);
75841     } catch (std::out_of_range& e) {
75842       {
75843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75844       };
75845     } catch (std::exception& e) {
75846       {
75847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75852       };
75853     }
75854   }
75855 }
75856
75857
75858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75859   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75860
75861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75862   {
75863     try {
75864       (arg1)->RemoveAllEffects();
75865     } catch (std::out_of_range& e) {
75866       {
75867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (std::exception& e) {
75870       {
75871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75876       };
75877     }
75878   }
75879 }
75880
75881
75882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75884   Dali::Actor arg2 ;
75885   Dali::Actor *argp2 ;
75886
75887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75888   argp2 = (Dali::Actor *)jarg2;
75889   if (!argp2) {
75890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75891     return ;
75892   }
75893   arg2 = *argp2;
75894   {
75895     try {
75896       (arg1)->BindActor(arg2);
75897     } catch (std::out_of_range& e) {
75898       {
75899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75900       };
75901     } catch (std::exception& e) {
75902       {
75903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75904       };
75905     } catch (...) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75908       };
75909     }
75910   }
75911 }
75912
75913
75914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75916   Dali::Actor arg2 ;
75917   Dali::Actor *argp2 ;
75918
75919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75920   argp2 = (Dali::Actor *)jarg2;
75921   if (!argp2) {
75922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75923     return ;
75924   }
75925   arg2 = *argp2;
75926   {
75927     try {
75928       (arg1)->UnbindActor(arg2);
75929     } catch (std::out_of_range& e) {
75930       {
75931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75932       };
75933     } catch (std::exception& e) {
75934       {
75935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75936       };
75937     } catch (...) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75940       };
75941     }
75942   }
75943 }
75944
75945
75946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75948   Dali::Radian arg2 ;
75949   Dali::Radian arg3 ;
75950   Dali::Radian *argp2 ;
75951   Dali::Radian *argp3 ;
75952
75953   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75954   argp2 = (Dali::Radian *)jarg2;
75955   if (!argp2) {
75956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75957     return ;
75958   }
75959   arg2 = *argp2;
75960   argp3 = (Dali::Radian *)jarg3;
75961   if (!argp3) {
75962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75963     return ;
75964   }
75965   arg3 = *argp3;
75966   {
75967     try {
75968       (arg1)->SetScrollingDirection(arg2,arg3);
75969     } catch (std::out_of_range& e) {
75970       {
75971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75972       };
75973     } catch (std::exception& e) {
75974       {
75975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75976       };
75977     } catch (...) {
75978       {
75979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75980       };
75981     }
75982   }
75983 }
75984
75985
75986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75988   Dali::Radian arg2 ;
75989   Dali::Radian *argp2 ;
75990
75991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75992   argp2 = (Dali::Radian *)jarg2;
75993   if (!argp2) {
75994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75995     return ;
75996   }
75997   arg2 = *argp2;
75998   {
75999     try {
76000       (arg1)->SetScrollingDirection(arg2);
76001     } catch (std::out_of_range& e) {
76002       {
76003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76004       };
76005     } catch (std::exception& e) {
76006       {
76007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76008       };
76009     } catch (...) {
76010       {
76011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76012       };
76013     }
76014   }
76015 }
76016
76017
76018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76019   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76020   Dali::Radian arg2 ;
76021   Dali::Radian *argp2 ;
76022
76023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76024   argp2 = (Dali::Radian *)jarg2;
76025   if (!argp2) {
76026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76027     return ;
76028   }
76029   arg2 = *argp2;
76030   {
76031     try {
76032       (arg1)->RemoveScrollingDirection(arg2);
76033     } catch (std::out_of_range& e) {
76034       {
76035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76036       };
76037     } catch (std::exception& e) {
76038       {
76039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76040       };
76041     } catch (...) {
76042       {
76043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76044       };
76045     }
76046   }
76047 }
76048
76049
76050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76051   void * jresult ;
76052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76053   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76054
76055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76056   {
76057     try {
76058       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76059     } catch (std::out_of_range& e) {
76060       {
76061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76062       };
76063     } catch (std::exception& e) {
76064       {
76065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76066       };
76067     } catch (...) {
76068       {
76069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76070       };
76071     }
76072   }
76073   jresult = (void *)result;
76074   return jresult;
76075 }
76076
76077
76078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76079   int jresult ;
76080   int result;
76081
76082   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76083   jresult = (int)result;
76084   return jresult;
76085 }
76086
76087
76088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76089   int jresult ;
76090   int result;
76091
76092   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76093   jresult = (int)result;
76094   return jresult;
76095 }
76096
76097
76098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76099   int jresult ;
76100   int result;
76101
76102   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76103   jresult = (int)result;
76104   return jresult;
76105 }
76106
76107
76108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76109   int jresult ;
76110   int result;
76111
76112   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76113   jresult = (int)result;
76114   return jresult;
76115 }
76116
76117
76118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76119   int jresult ;
76120   int result;
76121
76122   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76123   jresult = (int)result;
76124   return jresult;
76125 }
76126
76127
76128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76129   void * jresult ;
76130   Dali::Toolkit::TableView::Property *result = 0 ;
76131
76132   {
76133     try {
76134       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76135     } catch (std::out_of_range& e) {
76136       {
76137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76138       };
76139     } catch (std::exception& e) {
76140       {
76141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76142       };
76143     } catch (...) {
76144       {
76145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76146       };
76147     }
76148   }
76149   jresult = (void *)result;
76150   return jresult;
76151 }
76152
76153
76154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76155   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76156
76157   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76158   {
76159     try {
76160       delete arg1;
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175 }
76176
76177
76178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76179   int jresult ;
76180   int result;
76181
76182   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76183   jresult = (int)result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76189   int jresult ;
76190   int result;
76191
76192   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76193   jresult = (int)result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76199   int jresult ;
76200   int result;
76201
76202   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76203   jresult = (int)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76209   int jresult ;
76210   int result;
76211
76212   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76213   jresult = (int)result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76219   int jresult ;
76220   int result;
76221
76222   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76223   jresult = (int)result;
76224   return jresult;
76225 }
76226
76227
76228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76229   void * jresult ;
76230   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76231
76232   {
76233     try {
76234       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76235     } catch (std::out_of_range& e) {
76236       {
76237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76238       };
76239     } catch (std::exception& e) {
76240       {
76241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76242       };
76243     } catch (...) {
76244       {
76245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76246       };
76247     }
76248   }
76249   jresult = (void *)result;
76250   return jresult;
76251 }
76252
76253
76254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76255   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76256
76257   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76258   {
76259     try {
76260       delete arg1;
76261     } catch (std::out_of_range& e) {
76262       {
76263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76264       };
76265     } catch (std::exception& e) {
76266       {
76267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76268       };
76269     } catch (...) {
76270       {
76271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76272       };
76273     }
76274   }
76275 }
76276
76277
76278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76279   void * jresult ;
76280   unsigned int arg1 ;
76281   unsigned int arg2 ;
76282   unsigned int arg3 ;
76283   unsigned int arg4 ;
76284   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76285
76286   arg1 = (unsigned int)jarg1;
76287   arg2 = (unsigned int)jarg2;
76288   arg3 = (unsigned int)jarg3;
76289   arg4 = (unsigned int)jarg4;
76290   {
76291     try {
76292       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76293     } catch (std::out_of_range& e) {
76294       {
76295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76296       };
76297     } catch (std::exception& e) {
76298       {
76299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76300       };
76301     } catch (...) {
76302       {
76303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76304       };
76305     }
76306   }
76307   jresult = (void *)result;
76308   return jresult;
76309 }
76310
76311
76312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76313   void * jresult ;
76314   unsigned int arg1 ;
76315   unsigned int arg2 ;
76316   unsigned int arg3 ;
76317   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76318
76319   arg1 = (unsigned int)jarg1;
76320   arg2 = (unsigned int)jarg2;
76321   arg3 = (unsigned int)jarg3;
76322   {
76323     try {
76324       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76325     } catch (std::out_of_range& e) {
76326       {
76327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76328       };
76329     } catch (std::exception& e) {
76330       {
76331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76336       };
76337     }
76338   }
76339   jresult = (void *)result;
76340   return jresult;
76341 }
76342
76343
76344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76345   void * jresult ;
76346   unsigned int arg1 ;
76347   unsigned int arg2 ;
76348   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76349
76350   arg1 = (unsigned int)jarg1;
76351   arg2 = (unsigned int)jarg2;
76352   {
76353     try {
76354       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76355     } catch (std::out_of_range& e) {
76356       {
76357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76358       };
76359     } catch (std::exception& e) {
76360       {
76361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76362       };
76363     } catch (...) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76366       };
76367     }
76368   }
76369   jresult = (void *)result;
76370   return jresult;
76371 }
76372
76373
76374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76375   void * jresult ;
76376   unsigned int arg1 ;
76377   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76378
76379   arg1 = (unsigned int)jarg1;
76380   {
76381     try {
76382       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (...) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76394       };
76395     }
76396   }
76397   jresult = (void *)result;
76398   return jresult;
76399 }
76400
76401
76402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76403   void * jresult ;
76404   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76405
76406   {
76407     try {
76408       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76409     } catch (std::out_of_range& e) {
76410       {
76411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76412       };
76413     } catch (std::exception& e) {
76414       {
76415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (...) {
76418       {
76419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76420       };
76421     }
76422   }
76423   jresult = (void *)result;
76424   return jresult;
76425 }
76426
76427
76428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76429   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76430   unsigned int arg2 ;
76431
76432   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76433   arg2 = (unsigned int)jarg2;
76434   if (arg1) (arg1)->rowIndex = arg2;
76435 }
76436
76437
76438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76439   unsigned int jresult ;
76440   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76441   unsigned int result;
76442
76443   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76444   result = (unsigned int) ((arg1)->rowIndex);
76445   jresult = result;
76446   return jresult;
76447 }
76448
76449
76450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76451   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76452   unsigned int arg2 ;
76453
76454   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76455   arg2 = (unsigned int)jarg2;
76456   if (arg1) (arg1)->columnIndex = arg2;
76457 }
76458
76459
76460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76461   unsigned int jresult ;
76462   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76463   unsigned int result;
76464
76465   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76466   result = (unsigned int) ((arg1)->columnIndex);
76467   jresult = result;
76468   return jresult;
76469 }
76470
76471
76472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76473   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76474   unsigned int arg2 ;
76475
76476   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76477   arg2 = (unsigned int)jarg2;
76478   if (arg1) (arg1)->rowSpan = arg2;
76479 }
76480
76481
76482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76483   unsigned int jresult ;
76484   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76485   unsigned int result;
76486
76487   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76488   result = (unsigned int) ((arg1)->rowSpan);
76489   jresult = result;
76490   return jresult;
76491 }
76492
76493
76494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76495   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76496   unsigned int arg2 ;
76497
76498   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76499   arg2 = (unsigned int)jarg2;
76500   if (arg1) (arg1)->columnSpan = arg2;
76501 }
76502
76503
76504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76505   unsigned int jresult ;
76506   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76507   unsigned int result;
76508
76509   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76510   result = (unsigned int) ((arg1)->columnSpan);
76511   jresult = result;
76512   return jresult;
76513 }
76514
76515
76516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76517   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76518
76519   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76520   {
76521     try {
76522       delete arg1;
76523     } catch (std::out_of_range& e) {
76524       {
76525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76526       };
76527     } catch (std::exception& e) {
76528       {
76529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76530       };
76531     } catch (...) {
76532       {
76533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76534       };
76535     }
76536   }
76537 }
76538
76539
76540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76541   void * jresult ;
76542   Dali::Toolkit::TableView *result = 0 ;
76543
76544   {
76545     try {
76546       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
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 (...) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76558       };
76559     }
76560   }
76561   jresult = (void *)result;
76562   return jresult;
76563 }
76564
76565
76566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76567   void * jresult ;
76568   Dali::Toolkit::TableView *arg1 = 0 ;
76569   Dali::Toolkit::TableView *result = 0 ;
76570
76571   arg1 = (Dali::Toolkit::TableView *)jarg1;
76572   if (!arg1) {
76573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76574     return 0;
76575   }
76576   {
76577     try {
76578       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76579     } catch (std::out_of_range& e) {
76580       {
76581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76582       };
76583     } catch (std::exception& e) {
76584       {
76585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76586       };
76587     } catch (...) {
76588       {
76589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76590       };
76591     }
76592   }
76593   jresult = (void *)result;
76594   return jresult;
76595 }
76596
76597
76598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76599   void * jresult ;
76600   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76601   Dali::Toolkit::TableView *arg2 = 0 ;
76602   Dali::Toolkit::TableView *result = 0 ;
76603
76604   arg1 = (Dali::Toolkit::TableView *)jarg1;
76605   arg2 = (Dali::Toolkit::TableView *)jarg2;
76606   if (!arg2) {
76607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76608     return 0;
76609   }
76610   {
76611     try {
76612       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76613     } catch (std::out_of_range& e) {
76614       {
76615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76616       };
76617     } catch (std::exception& e) {
76618       {
76619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76620       };
76621     } catch (...) {
76622       {
76623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76624       };
76625     }
76626   }
76627   jresult = (void *)result;
76628   return jresult;
76629 }
76630
76631
76632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76633   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76634
76635   arg1 = (Dali::Toolkit::TableView *)jarg1;
76636   {
76637     try {
76638       delete arg1;
76639     } catch (std::out_of_range& e) {
76640       {
76641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76642       };
76643     } catch (std::exception& e) {
76644       {
76645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76646       };
76647     } catch (...) {
76648       {
76649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76650       };
76651     }
76652   }
76653 }
76654
76655
76656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76657   void * jresult ;
76658   unsigned int arg1 ;
76659   unsigned int arg2 ;
76660   Dali::Toolkit::TableView result;
76661
76662   arg1 = (unsigned int)jarg1;
76663   arg2 = (unsigned int)jarg2;
76664   {
76665     try {
76666       result = Dali::Toolkit::TableView::New(arg1,arg2);
76667     } catch (std::out_of_range& e) {
76668       {
76669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76670       };
76671     } catch (std::exception& e) {
76672       {
76673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76674       };
76675     } catch (...) {
76676       {
76677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76678       };
76679     }
76680   }
76681   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76682   return jresult;
76683 }
76684
76685
76686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76687   void * jresult ;
76688   Dali::BaseHandle arg1 ;
76689   Dali::BaseHandle *argp1 ;
76690   Dali::Toolkit::TableView result;
76691
76692   argp1 = (Dali::BaseHandle *)jarg1;
76693   if (!argp1) {
76694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76695     return 0;
76696   }
76697   arg1 = *argp1;
76698   {
76699     try {
76700       result = Dali::Toolkit::TableView::DownCast(arg1);
76701     } catch (std::out_of_range& e) {
76702       {
76703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76704       };
76705     } catch (std::exception& e) {
76706       {
76707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76708       };
76709     } catch (...) {
76710       {
76711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76712       };
76713     }
76714   }
76715   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76716   return jresult;
76717 }
76718
76719
76720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76721   unsigned int jresult ;
76722   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76723   Dali::Actor arg2 ;
76724   Dali::Toolkit::TableView::CellPosition arg3 ;
76725   Dali::Actor *argp2 ;
76726   Dali::Toolkit::TableView::CellPosition *argp3 ;
76727   bool result;
76728
76729   arg1 = (Dali::Toolkit::TableView *)jarg1;
76730   argp2 = (Dali::Actor *)jarg2;
76731   if (!argp2) {
76732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76733     return 0;
76734   }
76735   arg2 = *argp2;
76736   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76737   if (!argp3) {
76738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76739     return 0;
76740   }
76741   arg3 = *argp3;
76742   {
76743     try {
76744       result = (bool)(arg1)->AddChild(arg2,arg3);
76745     } catch (std::out_of_range& e) {
76746       {
76747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76748       };
76749     } catch (std::exception& e) {
76750       {
76751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76752       };
76753     } catch (...) {
76754       {
76755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76756       };
76757     }
76758   }
76759   jresult = result;
76760   return jresult;
76761 }
76762
76763
76764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76765   void * jresult ;
76766   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76767   Dali::Toolkit::TableView::CellPosition arg2 ;
76768   Dali::Toolkit::TableView::CellPosition *argp2 ;
76769   Dali::Actor result;
76770
76771   arg1 = (Dali::Toolkit::TableView *)jarg1;
76772   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76773   if (!argp2) {
76774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76775     return 0;
76776   }
76777   arg2 = *argp2;
76778   {
76779     try {
76780       result = (arg1)->GetChildAt(arg2);
76781     } catch (std::out_of_range& e) {
76782       {
76783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76784       };
76785     } catch (std::exception& e) {
76786       {
76787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76788       };
76789     } catch (...) {
76790       {
76791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76792       };
76793     }
76794   }
76795   jresult = new Dali::Actor((const Dali::Actor &)result);
76796   return jresult;
76797 }
76798
76799
76800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76801   void * jresult ;
76802   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76803   Dali::Toolkit::TableView::CellPosition arg2 ;
76804   Dali::Toolkit::TableView::CellPosition *argp2 ;
76805   Dali::Actor result;
76806
76807   arg1 = (Dali::Toolkit::TableView *)jarg1;
76808   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76809   if (!argp2) {
76810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76811     return 0;
76812   }
76813   arg2 = *argp2;
76814   {
76815     try {
76816       result = (arg1)->RemoveChildAt(arg2);
76817     } catch (std::out_of_range& e) {
76818       {
76819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76820       };
76821     } catch (std::exception& e) {
76822       {
76823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76824       };
76825     } catch (...) {
76826       {
76827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76828       };
76829     }
76830   }
76831   jresult = new Dali::Actor((const Dali::Actor &)result);
76832   return jresult;
76833 }
76834
76835
76836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76837   unsigned int jresult ;
76838   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76839   Dali::Actor arg2 ;
76840   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76841   Dali::Actor *argp2 ;
76842   bool result;
76843
76844   arg1 = (Dali::Toolkit::TableView *)jarg1;
76845   argp2 = (Dali::Actor *)jarg2;
76846   if (!argp2) {
76847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76848     return 0;
76849   }
76850   arg2 = *argp2;
76851   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76852   if (!arg3) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76854     return 0;
76855   }
76856   {
76857     try {
76858       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76870       };
76871     }
76872   }
76873   jresult = result;
76874   return jresult;
76875 }
76876
76877
76878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76879   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76880   unsigned int arg2 ;
76881
76882   arg1 = (Dali::Toolkit::TableView *)jarg1;
76883   arg2 = (unsigned int)jarg2;
76884   {
76885     try {
76886       (arg1)->InsertRow(arg2);
76887     } catch (std::out_of_range& e) {
76888       {
76889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76890       };
76891     } catch (std::exception& e) {
76892       {
76893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76894       };
76895     } catch (...) {
76896       {
76897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76898       };
76899     }
76900   }
76901 }
76902
76903
76904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76905   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76906   unsigned int arg2 ;
76907
76908   arg1 = (Dali::Toolkit::TableView *)jarg1;
76909   arg2 = (unsigned int)jarg2;
76910   {
76911     try {
76912       (arg1)->DeleteRow(arg2);
76913     } catch (std::out_of_range& e) {
76914       {
76915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76916       };
76917     } catch (std::exception& e) {
76918       {
76919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (...) {
76922       {
76923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76924       };
76925     }
76926   }
76927 }
76928
76929
76930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76931   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76932   unsigned int arg2 ;
76933   std::vector< Dali::Actor > *arg3 = 0 ;
76934
76935   arg1 = (Dali::Toolkit::TableView *)jarg1;
76936   arg2 = (unsigned int)jarg2;
76937   arg3 = (std::vector< Dali::Actor > *)jarg3;
76938   if (!arg3) {
76939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76940     return ;
76941   }
76942   {
76943     try {
76944       (arg1)->DeleteRow(arg2,*arg3);
76945     } catch (std::out_of_range& e) {
76946       {
76947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76948       };
76949     } catch (std::exception& e) {
76950       {
76951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76952       };
76953     } catch (...) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76956       };
76957     }
76958   }
76959 }
76960
76961
76962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76963   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76964   unsigned int arg2 ;
76965
76966   arg1 = (Dali::Toolkit::TableView *)jarg1;
76967   arg2 = (unsigned int)jarg2;
76968   {
76969     try {
76970       (arg1)->InsertColumn(arg2);
76971     } catch (std::out_of_range& e) {
76972       {
76973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76974       };
76975     } catch (std::exception& e) {
76976       {
76977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76978       };
76979     } catch (...) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76982       };
76983     }
76984   }
76985 }
76986
76987
76988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76989   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76990   unsigned int arg2 ;
76991
76992   arg1 = (Dali::Toolkit::TableView *)jarg1;
76993   arg2 = (unsigned int)jarg2;
76994   {
76995     try {
76996       (arg1)->DeleteColumn(arg2);
76997     } catch (std::out_of_range& e) {
76998       {
76999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77000       };
77001     } catch (std::exception& e) {
77002       {
77003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77004       };
77005     } catch (...) {
77006       {
77007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77008       };
77009     }
77010   }
77011 }
77012
77013
77014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77016   unsigned int arg2 ;
77017   std::vector< Dali::Actor > *arg3 = 0 ;
77018
77019   arg1 = (Dali::Toolkit::TableView *)jarg1;
77020   arg2 = (unsigned int)jarg2;
77021   arg3 = (std::vector< Dali::Actor > *)jarg3;
77022   if (!arg3) {
77023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77024     return ;
77025   }
77026   {
77027     try {
77028       (arg1)->DeleteColumn(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 (...) {
77038       {
77039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77040       };
77041     }
77042   }
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77048   unsigned int arg2 ;
77049   unsigned int arg3 ;
77050
77051   arg1 = (Dali::Toolkit::TableView *)jarg1;
77052   arg2 = (unsigned int)jarg2;
77053   arg3 = (unsigned int)jarg3;
77054   {
77055     try {
77056       (arg1)->Resize(arg2,arg3);
77057     } catch (std::out_of_range& e) {
77058       {
77059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (std::exception& e) {
77062       {
77063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77068       };
77069     }
77070   }
77071 }
77072
77073
77074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77075   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77076   unsigned int arg2 ;
77077   unsigned int arg3 ;
77078   std::vector< Dali::Actor > *arg4 = 0 ;
77079
77080   arg1 = (Dali::Toolkit::TableView *)jarg1;
77081   arg2 = (unsigned int)jarg2;
77082   arg3 = (unsigned int)jarg3;
77083   arg4 = (std::vector< Dali::Actor > *)jarg4;
77084   if (!arg4) {
77085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77086     return ;
77087   }
77088   {
77089     try {
77090       (arg1)->Resize(arg2,arg3,*arg4);
77091     } catch (std::out_of_range& e) {
77092       {
77093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77094       };
77095     } catch (std::exception& e) {
77096       {
77097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77098       };
77099     } catch (...) {
77100       {
77101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77102       };
77103     }
77104   }
77105 }
77106
77107
77108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77109   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77110   Dali::Size arg2 ;
77111   Dali::Size *argp2 ;
77112
77113   arg1 = (Dali::Toolkit::TableView *)jarg1;
77114   argp2 = (Dali::Size *)jarg2;
77115   if (!argp2) {
77116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77117     return ;
77118   }
77119   arg2 = *argp2;
77120   {
77121     try {
77122       (arg1)->SetCellPadding(arg2);
77123     } catch (std::out_of_range& e) {
77124       {
77125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77126       };
77127     } catch (std::exception& e) {
77128       {
77129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77130       };
77131     } catch (...) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77134       };
77135     }
77136   }
77137 }
77138
77139
77140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77141   void * jresult ;
77142   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77143   Dali::Size result;
77144
77145   arg1 = (Dali::Toolkit::TableView *)jarg1;
77146   {
77147     try {
77148       result = (arg1)->GetCellPadding();
77149     } catch (std::out_of_range& e) {
77150       {
77151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77152       };
77153     } catch (std::exception& e) {
77154       {
77155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77156       };
77157     } catch (...) {
77158       {
77159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77160       };
77161     }
77162   }
77163   jresult = new Dali::Size((const Dali::Size &)result);
77164   return jresult;
77165 }
77166
77167
77168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77169   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77170   unsigned int arg2 ;
77171
77172   arg1 = (Dali::Toolkit::TableView *)jarg1;
77173   arg2 = (unsigned int)jarg2;
77174   {
77175     try {
77176       (arg1)->SetFitHeight(arg2);
77177     } catch (std::out_of_range& e) {
77178       {
77179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77180       };
77181     } catch (std::exception& e) {
77182       {
77183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77184       };
77185     } catch (...) {
77186       {
77187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77188       };
77189     }
77190   }
77191 }
77192
77193
77194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77195   unsigned int jresult ;
77196   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77197   unsigned int arg2 ;
77198   bool result;
77199
77200   arg1 = (Dali::Toolkit::TableView *)jarg1;
77201   arg2 = (unsigned int)jarg2;
77202   {
77203     try {
77204       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77205     } catch (std::out_of_range& e) {
77206       {
77207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77208       };
77209     } catch (std::exception& e) {
77210       {
77211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77212       };
77213     } catch (...) {
77214       {
77215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77216       };
77217     }
77218   }
77219   jresult = result;
77220   return jresult;
77221 }
77222
77223
77224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77226   unsigned int arg2 ;
77227
77228   arg1 = (Dali::Toolkit::TableView *)jarg1;
77229   arg2 = (unsigned int)jarg2;
77230   {
77231     try {
77232       (arg1)->SetFitWidth(arg2);
77233     } catch (std::out_of_range& e) {
77234       {
77235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77236       };
77237     } catch (std::exception& e) {
77238       {
77239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77240       };
77241     } catch (...) {
77242       {
77243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77244       };
77245     }
77246   }
77247 }
77248
77249
77250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77251   unsigned int jresult ;
77252   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77253   unsigned int arg2 ;
77254   bool result;
77255
77256   arg1 = (Dali::Toolkit::TableView *)jarg1;
77257   arg2 = (unsigned int)jarg2;
77258   {
77259     try {
77260       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77261     } catch (std::out_of_range& e) {
77262       {
77263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77264       };
77265     } catch (std::exception& e) {
77266       {
77267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77268       };
77269     } catch (...) {
77270       {
77271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77272       };
77273     }
77274   }
77275   jresult = result;
77276   return jresult;
77277 }
77278
77279
77280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77281   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77282   unsigned int arg2 ;
77283   float arg3 ;
77284
77285   arg1 = (Dali::Toolkit::TableView *)jarg1;
77286   arg2 = (unsigned int)jarg2;
77287   arg3 = (float)jarg3;
77288   {
77289     try {
77290       (arg1)->SetFixedHeight(arg2,arg3);
77291     } catch (std::out_of_range& e) {
77292       {
77293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77294       };
77295     } catch (std::exception& e) {
77296       {
77297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77298       };
77299     } catch (...) {
77300       {
77301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77302       };
77303     }
77304   }
77305 }
77306
77307
77308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77309   float jresult ;
77310   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77311   unsigned int arg2 ;
77312   float result;
77313
77314   arg1 = (Dali::Toolkit::TableView *)jarg1;
77315   arg2 = (unsigned int)jarg2;
77316   {
77317     try {
77318       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77319     } catch (std::out_of_range& e) {
77320       {
77321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77322       };
77323     } catch (std::exception& e) {
77324       {
77325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77326       };
77327     } catch (...) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77330       };
77331     }
77332   }
77333   jresult = result;
77334   return jresult;
77335 }
77336
77337
77338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77339   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77340   unsigned int arg2 ;
77341   float arg3 ;
77342
77343   arg1 = (Dali::Toolkit::TableView *)jarg1;
77344   arg2 = (unsigned int)jarg2;
77345   arg3 = (float)jarg3;
77346   {
77347     try {
77348       (arg1)->SetRelativeHeight(arg2,arg3);
77349     } catch (std::out_of_range& e) {
77350       {
77351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77352       };
77353     } catch (std::exception& e) {
77354       {
77355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77356       };
77357     } catch (...) {
77358       {
77359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77360       };
77361     }
77362   }
77363 }
77364
77365
77366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77367   float jresult ;
77368   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77369   unsigned int arg2 ;
77370   float result;
77371
77372   arg1 = (Dali::Toolkit::TableView *)jarg1;
77373   arg2 = (unsigned int)jarg2;
77374   {
77375     try {
77376       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77377     } catch (std::out_of_range& e) {
77378       {
77379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77380       };
77381     } catch (std::exception& e) {
77382       {
77383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77384       };
77385     } catch (...) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77388       };
77389     }
77390   }
77391   jresult = result;
77392   return jresult;
77393 }
77394
77395
77396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77397   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77398   unsigned int arg2 ;
77399   float arg3 ;
77400
77401   arg1 = (Dali::Toolkit::TableView *)jarg1;
77402   arg2 = (unsigned int)jarg2;
77403   arg3 = (float)jarg3;
77404   {
77405     try {
77406       (arg1)->SetFixedWidth(arg2,arg3);
77407     } catch (std::out_of_range& e) {
77408       {
77409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77410       };
77411     } catch (std::exception& e) {
77412       {
77413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77414       };
77415     } catch (...) {
77416       {
77417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77418       };
77419     }
77420   }
77421 }
77422
77423
77424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77425   float jresult ;
77426   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77427   unsigned int arg2 ;
77428   float result;
77429
77430   arg1 = (Dali::Toolkit::TableView *)jarg1;
77431   arg2 = (unsigned int)jarg2;
77432   {
77433     try {
77434       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77435     } catch (std::out_of_range& e) {
77436       {
77437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77438       };
77439     } catch (std::exception& e) {
77440       {
77441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77442       };
77443     } catch (...) {
77444       {
77445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77446       };
77447     }
77448   }
77449   jresult = result;
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77455   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77456   unsigned int arg2 ;
77457   float arg3 ;
77458
77459   arg1 = (Dali::Toolkit::TableView *)jarg1;
77460   arg2 = (unsigned int)jarg2;
77461   arg3 = (float)jarg3;
77462   {
77463     try {
77464       (arg1)->SetRelativeWidth(arg2,arg3);
77465     } catch (std::out_of_range& e) {
77466       {
77467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77468       };
77469     } catch (std::exception& e) {
77470       {
77471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77472       };
77473     } catch (...) {
77474       {
77475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77476       };
77477     }
77478   }
77479 }
77480
77481
77482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77483   float jresult ;
77484   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77485   unsigned int arg2 ;
77486   float result;
77487
77488   arg1 = (Dali::Toolkit::TableView *)jarg1;
77489   arg2 = (unsigned int)jarg2;
77490   {
77491     try {
77492       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77493     } catch (std::out_of_range& e) {
77494       {
77495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77496       };
77497     } catch (std::exception& e) {
77498       {
77499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77500       };
77501     } catch (...) {
77502       {
77503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77504       };
77505     }
77506   }
77507   jresult = result;
77508   return jresult;
77509 }
77510
77511
77512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77513   unsigned int jresult ;
77514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77515   unsigned int result;
77516
77517   arg1 = (Dali::Toolkit::TableView *)jarg1;
77518   {
77519     try {
77520       result = (unsigned int)(arg1)->GetRows();
77521     } catch (std::out_of_range& e) {
77522       {
77523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77524       };
77525     } catch (std::exception& e) {
77526       {
77527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77528       };
77529     } catch (...) {
77530       {
77531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77532       };
77533     }
77534   }
77535   jresult = result;
77536   return jresult;
77537 }
77538
77539
77540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77541   unsigned int jresult ;
77542   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77543   unsigned int result;
77544
77545   arg1 = (Dali::Toolkit::TableView *)jarg1;
77546   {
77547     try {
77548       result = (unsigned int)(arg1)->GetColumns();
77549     } catch (std::out_of_range& e) {
77550       {
77551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77552       };
77553     } catch (std::exception& e) {
77554       {
77555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77556       };
77557     } catch (...) {
77558       {
77559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77560       };
77561     }
77562   }
77563   jresult = result;
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77569   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77570   Dali::Toolkit::TableView::CellPosition arg2 ;
77571   Dali::HorizontalAlignment::Type arg3 ;
77572   Dali::VerticalAlignment::Type arg4 ;
77573   Dali::Toolkit::TableView::CellPosition *argp2 ;
77574
77575   arg1 = (Dali::Toolkit::TableView *)jarg1;
77576   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77577   if (!argp2) {
77578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77579     return ;
77580   }
77581   arg2 = *argp2;
77582   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77583   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77584   {
77585     try {
77586       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77587     } catch (std::out_of_range& e) {
77588       {
77589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77590       };
77591     } catch (std::exception& e) {
77592       {
77593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77594       };
77595     } catch (...) {
77596       {
77597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77598       };
77599     }
77600   }
77601 }
77602
77603
77604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77605   unsigned int jresult ;
77606   unsigned int result;
77607
77608   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77609   jresult = result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77615   int jresult ;
77616   int result;
77617
77618   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77619   jresult = (int)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77625   int jresult ;
77626   int result;
77627
77628   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77629   jresult = (int)result;
77630   return jresult;
77631 }
77632
77633
77634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77635   int jresult ;
77636   int result;
77637
77638   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77639   jresult = (int)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77645   int jresult ;
77646   int result;
77647
77648   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77649   jresult = (int)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77655   int jresult ;
77656   int result;
77657
77658   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77659   jresult = (int)result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77665   int jresult ;
77666   int result;
77667
77668   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77669   jresult = (int)result;
77670   return jresult;
77671 }
77672
77673
77674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77675   int jresult ;
77676   int result;
77677
77678   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77685   int jresult ;
77686   int result;
77687
77688   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77689   jresult = (int)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77735   int jresult ;
77736   int result;
77737
77738   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77739   jresult = (int)result;
77740   return jresult;
77741 }
77742
77743
77744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77745   int jresult ;
77746   int result;
77747
77748   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77749   jresult = (int)result;
77750   return jresult;
77751 }
77752
77753
77754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77755   int jresult ;
77756   int result;
77757
77758   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77759   jresult = (int)result;
77760   return jresult;
77761 }
77762
77763
77764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77765   int jresult ;
77766   int result;
77767
77768   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77769   jresult = (int)result;
77770   return jresult;
77771 }
77772
77773
77774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77775   int jresult ;
77776   int result;
77777
77778   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77779   jresult = (int)result;
77780   return jresult;
77781 }
77782
77783
77784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77785   int jresult ;
77786   int result;
77787
77788   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77789   jresult = (int)result;
77790   return jresult;
77791 }
77792
77793
77794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77795   int jresult ;
77796   int result;
77797
77798   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77799   jresult = (int)result;
77800   return jresult;
77801 }
77802
77803
77804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77805   int jresult ;
77806   int result;
77807
77808   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77809   jresult = (int)result;
77810   return jresult;
77811 }
77812
77813
77814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77815   int jresult ;
77816   int result;
77817
77818   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77819   jresult = (int)result;
77820   return jresult;
77821 }
77822
77823
77824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77825   int jresult ;
77826   int result;
77827
77828   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77829   jresult = (int)result;
77830   return jresult;
77831 }
77832
77833
77834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77835   int jresult ;
77836   int result;
77837
77838   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77839   jresult = (int)result;
77840   return jresult;
77841 }
77842
77843
77844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77845   int jresult ;
77846   int result;
77847
77848   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77849   jresult = (int)result;
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77855   int jresult ;
77856   int result;
77857
77858   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77859   jresult = (int)result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77865   int jresult ;
77866   int result;
77867
77868   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77869   jresult = (int)result;
77870   return jresult;
77871 }
77872
77873
77874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77875   int jresult ;
77876   int result;
77877
77878   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77879   jresult = (int)result;
77880   return jresult;
77881 }
77882
77883
77884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77885   int jresult ;
77886   int result;
77887
77888   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77889   jresult = (int)result;
77890   return jresult;
77891 }
77892
77893
77894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
77895   int jresult ;
77896   int result;
77897
77898   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77899   jresult = (int)result;
77900   return jresult;
77901 }
77902
77903
77904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
77905   int jresult ;
77906   int result;
77907
77908   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77909   jresult = (int)result;
77910   return jresult;
77911 }
77912
77913
77914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
77915   int jresult ;
77916   int result;
77917
77918   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77919   jresult = (int)result;
77920   return jresult;
77921 }
77922
77923
77924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
77925   int jresult ;
77926   int result;
77927
77928   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77929   jresult = (int)result;
77930   return jresult;
77931 }
77932
77933
77934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
77935   int jresult ;
77936   int result;
77937
77938   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77939   jresult = (int)result;
77940   return jresult;
77941 }
77942
77943
77944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77945   int jresult ;
77946   int result;
77947
77948   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77949   jresult = (int)result;
77950   return jresult;
77951 }
77952
77953
77954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77955   int jresult ;
77956   int result;
77957
77958   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77959   jresult = (int)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77965   int jresult ;
77966   int result;
77967
77968   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77969   jresult = (int)result;
77970   return jresult;
77971 }
77972
77973
77974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77975   int jresult ;
77976   int result;
77977
77978   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77979   jresult = (int)result;
77980   return jresult;
77981 }
77982
77983
77984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77985   int jresult ;
77986   int result;
77987
77988   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77989   jresult = (int)result;
77990   return jresult;
77991 }
77992
77993
77994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77995   int jresult ;
77996   int result;
77997
77998   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77999   jresult = (int)result;
78000   return jresult;
78001 }
78002
78003
78004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78005   int jresult ;
78006   int result;
78007
78008   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78009   jresult = (int)result;
78010   return jresult;
78011 }
78012
78013
78014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78015   void * jresult ;
78016   Dali::Toolkit::TextEditor::Property *result = 0 ;
78017
78018   {
78019     try {
78020       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78021     } catch (std::out_of_range& e) {
78022       {
78023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78024       };
78025     } catch (std::exception& e) {
78026       {
78027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78028       };
78029     } catch (...) {
78030       {
78031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78032       };
78033     }
78034   }
78035   jresult = (void *)result;
78036   return jresult;
78037 }
78038
78039
78040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78041   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78042
78043   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78044   {
78045     try {
78046       delete arg1;
78047     } catch (std::out_of_range& e) {
78048       {
78049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78050       };
78051     } catch (std::exception& e) {
78052       {
78053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78058       };
78059     }
78060   }
78061 }
78062
78063
78064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78065   void * jresult ;
78066   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78067
78068   {
78069     try {
78070       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78071     } catch (std::out_of_range& e) {
78072       {
78073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78074       };
78075     } catch (std::exception& e) {
78076       {
78077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78078       };
78079     } catch (...) {
78080       {
78081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78082       };
78083     }
78084   }
78085   jresult = (void *)result;
78086   return jresult;
78087 }
78088
78089
78090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78091   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78092
78093   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78094   {
78095     try {
78096       delete arg1;
78097     } catch (std::out_of_range& e) {
78098       {
78099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78100       };
78101     } catch (std::exception& e) {
78102       {
78103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78104       };
78105     } catch (...) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78108       };
78109     }
78110   }
78111 }
78112
78113
78114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78115   void * jresult ;
78116   Dali::Toolkit::TextEditor result;
78117
78118   {
78119     try {
78120       result = Dali::Toolkit::TextEditor::New();
78121     } catch (std::out_of_range& e) {
78122       {
78123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78124       };
78125     } catch (std::exception& e) {
78126       {
78127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78128       };
78129     } catch (...) {
78130       {
78131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78132       };
78133     }
78134   }
78135   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78136   return jresult;
78137 }
78138
78139
78140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78141   void * jresult ;
78142   Dali::Toolkit::TextEditor *result = 0 ;
78143
78144   {
78145     try {
78146       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78147     } catch (std::out_of_range& e) {
78148       {
78149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78150       };
78151     } catch (std::exception& e) {
78152       {
78153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78158       };
78159     }
78160   }
78161   jresult = (void *)result;
78162   return jresult;
78163 }
78164
78165
78166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78167   void * jresult ;
78168   Dali::Toolkit::TextEditor *arg1 = 0 ;
78169   Dali::Toolkit::TextEditor *result = 0 ;
78170
78171   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78172   if (!arg1) {
78173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78174     return 0;
78175   }
78176   {
78177     try {
78178       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78179     } catch (std::out_of_range& e) {
78180       {
78181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (std::exception& e) {
78184       {
78185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78186       };
78187     } catch (...) {
78188       {
78189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78190       };
78191     }
78192   }
78193   jresult = (void *)result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78199   void * jresult ;
78200   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78201   Dali::Toolkit::TextEditor *arg2 = 0 ;
78202   Dali::Toolkit::TextEditor *result = 0 ;
78203
78204   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78205   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78206   if (!arg2) {
78207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78208     return 0;
78209   }
78210   {
78211     try {
78212       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78213     } catch (std::out_of_range& e) {
78214       {
78215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78216       };
78217     } catch (std::exception& e) {
78218       {
78219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78220       };
78221     } catch (...) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78224       };
78225     }
78226   }
78227   jresult = (void *)result;
78228   return jresult;
78229 }
78230
78231
78232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78233   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78234
78235   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78236   {
78237     try {
78238       delete arg1;
78239     } catch (std::out_of_range& e) {
78240       {
78241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78242       };
78243     } catch (std::exception& e) {
78244       {
78245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78246       };
78247     } catch (...) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78250       };
78251     }
78252   }
78253 }
78254
78255
78256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78257   void * jresult ;
78258   Dali::BaseHandle arg1 ;
78259   Dali::BaseHandle *argp1 ;
78260   Dali::Toolkit::TextEditor result;
78261
78262   argp1 = (Dali::BaseHandle *)jarg1;
78263   if (!argp1) {
78264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78265     return 0;
78266   }
78267   arg1 = *argp1;
78268   {
78269     try {
78270       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78271     } catch (std::out_of_range& e) {
78272       {
78273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78274       };
78275     } catch (std::exception& e) {
78276       {
78277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (...) {
78280       {
78281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78282       };
78283     }
78284   }
78285   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78286   return jresult;
78287 }
78288
78289
78290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78291   void * jresult ;
78292   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78293   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78294
78295   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78296   {
78297     try {
78298       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78299     } catch (std::out_of_range& e) {
78300       {
78301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78302       };
78303     } catch (std::exception& e) {
78304       {
78305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78306       };
78307     } catch (...) {
78308       {
78309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78310       };
78311     }
78312   }
78313   jresult = (void *)result;
78314   return jresult;
78315 }
78316
78317
78318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78319   void * jresult ;
78320   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78321   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78322
78323   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78324   {
78325     try {
78326       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78327     } catch (std::out_of_range& e) {
78328       {
78329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78330       };
78331     } catch (std::exception& e) {
78332       {
78333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78334       };
78335     } catch (...) {
78336       {
78337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78338       };
78339     }
78340   }
78341   jresult = (void *)result;
78342   return jresult;
78343 }
78344
78345
78346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78347   int jresult ;
78348   int result;
78349
78350   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78351   jresult = (int)result;
78352   return jresult;
78353 }
78354
78355
78356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78357   int jresult ;
78358   int result;
78359
78360   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78361   jresult = (int)result;
78362   return jresult;
78363 }
78364
78365
78366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78367   int jresult ;
78368   int result;
78369
78370   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78371   jresult = (int)result;
78372   return jresult;
78373 }
78374
78375
78376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78377   int jresult ;
78378   int result;
78379
78380   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78381   jresult = (int)result;
78382   return jresult;
78383 }
78384
78385
78386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78387   int jresult ;
78388   int result;
78389
78390   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78391   jresult = (int)result;
78392   return jresult;
78393 }
78394
78395
78396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78397   int jresult ;
78398   int result;
78399
78400   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78401   jresult = (int)result;
78402   return jresult;
78403 }
78404
78405
78406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78407   int jresult ;
78408   int result;
78409
78410   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78411   jresult = (int)result;
78412   return jresult;
78413 }
78414
78415
78416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78417   int jresult ;
78418   int result;
78419
78420   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78421   jresult = (int)result;
78422   return jresult;
78423 }
78424
78425
78426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78427   int jresult ;
78428   int result;
78429
78430   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78431   jresult = (int)result;
78432   return jresult;
78433 }
78434
78435
78436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78437   int jresult ;
78438   int result;
78439
78440   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78441   jresult = (int)result;
78442   return jresult;
78443 }
78444
78445
78446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78447   int jresult ;
78448   int result;
78449
78450   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78451   jresult = (int)result;
78452   return jresult;
78453 }
78454
78455
78456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78457   int jresult ;
78458   int result;
78459
78460   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78461   jresult = (int)result;
78462   return jresult;
78463 }
78464
78465
78466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78467   int jresult ;
78468   int result;
78469
78470   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78471   jresult = (int)result;
78472   return jresult;
78473 }
78474
78475
78476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78477   int jresult ;
78478   int result;
78479
78480   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78481   jresult = (int)result;
78482   return jresult;
78483 }
78484
78485
78486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78487   int jresult ;
78488   int result;
78489
78490   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78491   jresult = (int)result;
78492   return jresult;
78493 }
78494
78495
78496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78497   int jresult ;
78498   int result;
78499
78500   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78501   jresult = (int)result;
78502   return jresult;
78503 }
78504
78505
78506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78507   int jresult ;
78508   int result;
78509
78510   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78511   jresult = (int)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78517   int jresult ;
78518   int result;
78519
78520   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78521   jresult = (int)result;
78522   return jresult;
78523 }
78524
78525
78526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78527   int jresult ;
78528   int result;
78529
78530   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78531   jresult = (int)result;
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78537   int jresult ;
78538   int result;
78539
78540   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78541   jresult = (int)result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78547   int jresult ;
78548   int result;
78549
78550   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78551   jresult = (int)result;
78552   return jresult;
78553 }
78554
78555
78556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78557   int jresult ;
78558   int result;
78559
78560   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78561   jresult = (int)result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78567   int jresult ;
78568   int result;
78569
78570   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78571   jresult = (int)result;
78572   return jresult;
78573 }
78574
78575
78576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78577   int jresult ;
78578   int result;
78579
78580   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78581   jresult = (int)result;
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78587   int jresult ;
78588   int result;
78589
78590   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78591   jresult = (int)result;
78592   return jresult;
78593 }
78594
78595
78596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78597   int jresult ;
78598   int result;
78599
78600   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78601   jresult = (int)result;
78602   return jresult;
78603 }
78604
78605
78606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78607   int jresult ;
78608   int result;
78609
78610   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78611   jresult = (int)result;
78612   return jresult;
78613 }
78614
78615
78616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78617   int jresult ;
78618   int result;
78619
78620   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78621   jresult = (int)result;
78622   return jresult;
78623 }
78624
78625
78626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78627   int jresult ;
78628   int result;
78629
78630   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78631   jresult = (int)result;
78632   return jresult;
78633 }
78634
78635
78636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78637   int jresult ;
78638   int result;
78639
78640   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78641   jresult = (int)result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78647   int jresult ;
78648   int result;
78649
78650   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78651   jresult = (int)result;
78652   return jresult;
78653 }
78654
78655
78656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78657   int jresult ;
78658   int result;
78659
78660   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78661   jresult = (int)result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78667   int jresult ;
78668   int result;
78669
78670   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78671   jresult = (int)result;
78672   return jresult;
78673 }
78674
78675
78676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78677   int jresult ;
78678   int result;
78679
78680   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78681   jresult = (int)result;
78682   return jresult;
78683 }
78684
78685
78686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78687   int jresult ;
78688   int result;
78689
78690   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78691   jresult = (int)result;
78692   return jresult;
78693 }
78694
78695
78696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78697   int jresult ;
78698   int result;
78699
78700   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78701   jresult = (int)result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78707   int jresult ;
78708   int result;
78709
78710   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78711   jresult = (int)result;
78712   return jresult;
78713 }
78714
78715
78716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78717   int jresult ;
78718   int result;
78719
78720   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78721   jresult = (int)result;
78722   return jresult;
78723 }
78724
78725
78726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78727   int jresult ;
78728   int result;
78729
78730   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78731   jresult = (int)result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78737   int jresult ;
78738   int result;
78739
78740   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78741   jresult = (int)result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78747   int jresult ;
78748   int result;
78749
78750   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78751   jresult = (int)result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78757   int jresult ;
78758   int result;
78759
78760   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78761   jresult = (int)result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78767   int jresult ;
78768   int result;
78769
78770   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78771   jresult = (int)result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78777   int jresult ;
78778   int result;
78779
78780   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78781   jresult = (int)result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78787   int jresult ;
78788   int result;
78789
78790   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78791   jresult = (int)result;
78792   return jresult;
78793 }
78794
78795
78796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78797   int jresult ;
78798   int result;
78799
78800   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78801   jresult = (int)result;
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78807   int jresult ;
78808   int result;
78809
78810   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78811   jresult = (int)result;
78812   return jresult;
78813 }
78814
78815
78816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78817   void * jresult ;
78818   Dali::Toolkit::TextField::Property *result = 0 ;
78819
78820   {
78821     try {
78822       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78823     } catch (std::out_of_range& e) {
78824       {
78825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78826       };
78827     } catch (std::exception& e) {
78828       {
78829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78830       };
78831     } catch (...) {
78832       {
78833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78834       };
78835     }
78836   }
78837   jresult = (void *)result;
78838   return jresult;
78839 }
78840
78841
78842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78843   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78844
78845   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78846   {
78847     try {
78848       delete arg1;
78849     } catch (std::out_of_range& e) {
78850       {
78851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78852       };
78853     } catch (std::exception& e) {
78854       {
78855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78856       };
78857     } catch (...) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78860       };
78861     }
78862   }
78863 }
78864
78865
78866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78867   void * jresult ;
78868   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78869
78870   {
78871     try {
78872       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78873     } catch (std::out_of_range& e) {
78874       {
78875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78876       };
78877     } catch (std::exception& e) {
78878       {
78879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78880       };
78881     } catch (...) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78884       };
78885     }
78886   }
78887   jresult = (void *)result;
78888   return jresult;
78889 }
78890
78891
78892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78893   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78894
78895   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78896   {
78897     try {
78898       delete arg1;
78899     } catch (std::out_of_range& e) {
78900       {
78901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78902       };
78903     } catch (std::exception& e) {
78904       {
78905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78906       };
78907     } catch (...) {
78908       {
78909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78910       };
78911     }
78912   }
78913 }
78914
78915
78916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
78917   void * jresult ;
78918   Dali::Toolkit::TextField result;
78919
78920   {
78921     try {
78922       result = Dali::Toolkit::TextField::New();
78923     } catch (std::out_of_range& e) {
78924       {
78925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78926       };
78927     } catch (std::exception& e) {
78928       {
78929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78930       };
78931     } catch (...) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78934       };
78935     }
78936   }
78937   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78938   return jresult;
78939 }
78940
78941
78942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78943   void * jresult ;
78944   Dali::Toolkit::TextField *result = 0 ;
78945
78946   {
78947     try {
78948       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78956       };
78957     } catch (...) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78960       };
78961     }
78962   }
78963   jresult = (void *)result;
78964   return jresult;
78965 }
78966
78967
78968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78969   void * jresult ;
78970   Dali::Toolkit::TextField *arg1 = 0 ;
78971   Dali::Toolkit::TextField *result = 0 ;
78972
78973   arg1 = (Dali::Toolkit::TextField *)jarg1;
78974   if (!arg1) {
78975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78976     return 0;
78977   }
78978   {
78979     try {
78980       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (...) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78992       };
78993     }
78994   }
78995   jresult = (void *)result;
78996   return jresult;
78997 }
78998
78999
79000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79001   void * jresult ;
79002   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79003   Dali::Toolkit::TextField *arg2 = 0 ;
79004   Dali::Toolkit::TextField *result = 0 ;
79005
79006   arg1 = (Dali::Toolkit::TextField *)jarg1;
79007   arg2 = (Dali::Toolkit::TextField *)jarg2;
79008   if (!arg2) {
79009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79010     return 0;
79011   }
79012   {
79013     try {
79014       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79015     } catch (std::out_of_range& e) {
79016       {
79017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79018       };
79019     } catch (std::exception& e) {
79020       {
79021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79022       };
79023     } catch (...) {
79024       {
79025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79026       };
79027     }
79028   }
79029   jresult = (void *)result;
79030   return jresult;
79031 }
79032
79033
79034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79035   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79036
79037   arg1 = (Dali::Toolkit::TextField *)jarg1;
79038   {
79039     try {
79040       delete arg1;
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79052       };
79053     }
79054   }
79055 }
79056
79057
79058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79059   void * jresult ;
79060   Dali::BaseHandle arg1 ;
79061   Dali::BaseHandle *argp1 ;
79062   Dali::Toolkit::TextField result;
79063
79064   argp1 = (Dali::BaseHandle *)jarg1;
79065   if (!argp1) {
79066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79067     return 0;
79068   }
79069   arg1 = *argp1;
79070   {
79071     try {
79072       result = Dali::Toolkit::TextField::DownCast(arg1);
79073     } catch (std::out_of_range& e) {
79074       {
79075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79076       };
79077     } catch (std::exception& e) {
79078       {
79079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79080       };
79081     } catch (...) {
79082       {
79083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79084       };
79085     }
79086   }
79087   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79088   return jresult;
79089 }
79090
79091
79092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79093   void * jresult ;
79094   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79095   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79096
79097   arg1 = (Dali::Toolkit::TextField *)jarg1;
79098   {
79099     try {
79100       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79101     } catch (std::out_of_range& e) {
79102       {
79103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79104       };
79105     } catch (std::exception& e) {
79106       {
79107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (...) {
79110       {
79111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79112       };
79113     }
79114   }
79115   jresult = (void *)result;
79116   return jresult;
79117 }
79118
79119
79120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79121   void * jresult ;
79122   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79123   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79124
79125   arg1 = (Dali::Toolkit::TextField *)jarg1;
79126   {
79127     try {
79128       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (...) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79140       };
79141     }
79142   }
79143   jresult = (void *)result;
79144   return jresult;
79145 }
79146
79147
79148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79149   void * jresult ;
79150   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79151   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79152
79153   arg1 = (Dali::Toolkit::TextField *)jarg1;
79154   {
79155     try {
79156       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79168       };
79169     }
79170   }
79171   jresult = (void *)result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79177   int jresult ;
79178   int result;
79179
79180   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79181   jresult = (int)result;
79182   return jresult;
79183 }
79184
79185
79186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79187   int jresult ;
79188   int result;
79189
79190   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79191   jresult = (int)result;
79192   return jresult;
79193 }
79194
79195
79196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79197   int jresult ;
79198   int result;
79199
79200   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79201   jresult = (int)result;
79202   return jresult;
79203 }
79204
79205
79206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79207   int jresult ;
79208   int result;
79209
79210   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79211   jresult = (int)result;
79212   return jresult;
79213 }
79214
79215
79216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79217   int jresult ;
79218   int result;
79219
79220   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79221   jresult = (int)result;
79222   return jresult;
79223 }
79224
79225
79226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79227   int jresult ;
79228   int result;
79229
79230   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79231   jresult = (int)result;
79232   return jresult;
79233 }
79234
79235
79236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79237   int jresult ;
79238   int result;
79239
79240   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79241   jresult = (int)result;
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79247   int jresult ;
79248   int result;
79249
79250   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79251   jresult = (int)result;
79252   return jresult;
79253 }
79254
79255
79256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79257   int jresult ;
79258   int result;
79259
79260   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79261   jresult = (int)result;
79262   return jresult;
79263 }
79264
79265
79266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79267   int jresult ;
79268   int result;
79269
79270   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79271   jresult = (int)result;
79272   return jresult;
79273 }
79274
79275
79276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79277   int jresult ;
79278   int result;
79279
79280   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79281   jresult = (int)result;
79282   return jresult;
79283 }
79284
79285
79286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79287   int jresult ;
79288   int result;
79289
79290   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79291   jresult = (int)result;
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79297   int jresult ;
79298   int result;
79299
79300   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79301   jresult = (int)result;
79302   return jresult;
79303 }
79304
79305
79306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79307   int jresult ;
79308   int result;
79309
79310   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79311   jresult = (int)result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79317   int jresult ;
79318   int result;
79319
79320   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79321   jresult = (int)result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79327   int jresult ;
79328   int result;
79329
79330   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79331   jresult = (int)result;
79332   return jresult;
79333 }
79334
79335
79336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79337   int jresult ;
79338   int result;
79339
79340   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79341   jresult = (int)result;
79342   return jresult;
79343 }
79344
79345
79346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79347   int jresult ;
79348   int result;
79349
79350   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79351   jresult = (int)result;
79352   return jresult;
79353 }
79354
79355
79356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79357   int jresult ;
79358   int result;
79359
79360   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79361   jresult = (int)result;
79362   return jresult;
79363 }
79364
79365
79366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79367   int jresult ;
79368   int result;
79369
79370   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79371   jresult = (int)result;
79372   return jresult;
79373 }
79374
79375
79376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79377   int jresult ;
79378   int result;
79379
79380   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79381   jresult = (int)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79387   int jresult ;
79388   int result;
79389
79390   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79391   jresult = (int)result;
79392   return jresult;
79393 }
79394
79395
79396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79397   int jresult ;
79398   int result;
79399
79400   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79401   jresult = (int)result;
79402   return jresult;
79403 }
79404
79405
79406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79407   int jresult ;
79408   int result;
79409
79410   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79411   jresult = (int)result;
79412   return jresult;
79413 }
79414
79415
79416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79417   void * jresult ;
79418   Dali::Toolkit::TextLabel::Property *result = 0 ;
79419
79420   {
79421     try {
79422       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79423     } catch (std::out_of_range& e) {
79424       {
79425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79426       };
79427     } catch (std::exception& e) {
79428       {
79429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79430       };
79431     } catch (...) {
79432       {
79433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79434       };
79435     }
79436   }
79437   jresult = (void *)result;
79438   return jresult;
79439 }
79440
79441
79442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79443   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79444
79445   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79446   {
79447     try {
79448       delete arg1;
79449     } catch (std::out_of_range& e) {
79450       {
79451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79452       };
79453     } catch (std::exception& e) {
79454       {
79455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79456       };
79457     } catch (...) {
79458       {
79459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79460       };
79461     }
79462   }
79463 }
79464
79465
79466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79467   void * jresult ;
79468   Dali::Toolkit::TextLabel result;
79469
79470   {
79471     try {
79472       result = Dali::Toolkit::TextLabel::New();
79473     } catch (std::out_of_range& e) {
79474       {
79475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79476       };
79477     } catch (std::exception& e) {
79478       {
79479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79480       };
79481     } catch (...) {
79482       {
79483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79484       };
79485     }
79486   }
79487   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79488   return jresult;
79489 }
79490
79491
79492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79493   void * jresult ;
79494   std::string *arg1 = 0 ;
79495   Dali::Toolkit::TextLabel result;
79496
79497   if (!jarg1) {
79498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79499     return 0;
79500   }
79501   std::string arg1_str(jarg1);
79502   arg1 = &arg1_str;
79503   {
79504     try {
79505       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79506     } catch (std::out_of_range& e) {
79507       {
79508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (std::exception& e) {
79511       {
79512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79513       };
79514     } catch (...) {
79515       {
79516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79517       };
79518     }
79519   }
79520   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79521
79522   //argout typemap for const std::string&
79523
79524   return jresult;
79525 }
79526
79527
79528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79529   void * jresult ;
79530   Dali::Toolkit::TextLabel *result = 0 ;
79531
79532   {
79533     try {
79534       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79535     } catch (std::out_of_range& e) {
79536       {
79537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (std::exception& e) {
79540       {
79541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (...) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79546       };
79547     }
79548   }
79549   jresult = (void *)result;
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79555   void * jresult ;
79556   Dali::Toolkit::TextLabel *arg1 = 0 ;
79557   Dali::Toolkit::TextLabel *result = 0 ;
79558
79559   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79560   if (!arg1) {
79561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79562     return 0;
79563   }
79564   {
79565     try {
79566       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79567     } catch (std::out_of_range& e) {
79568       {
79569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79570       };
79571     } catch (std::exception& e) {
79572       {
79573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79574       };
79575     } catch (...) {
79576       {
79577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79578       };
79579     }
79580   }
79581   jresult = (void *)result;
79582   return jresult;
79583 }
79584
79585
79586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79587   void * jresult ;
79588   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79589   Dali::Toolkit::TextLabel *arg2 = 0 ;
79590   Dali::Toolkit::TextLabel *result = 0 ;
79591
79592   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79593   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79594   if (!arg2) {
79595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79596     return 0;
79597   }
79598   {
79599     try {
79600       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79601     } catch (std::out_of_range& e) {
79602       {
79603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79604       };
79605     } catch (std::exception& e) {
79606       {
79607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79608       };
79609     } catch (...) {
79610       {
79611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79612       };
79613     }
79614   }
79615   jresult = (void *)result;
79616   return jresult;
79617 }
79618
79619
79620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79621   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79622
79623   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79624   {
79625     try {
79626       delete arg1;
79627     } catch (std::out_of_range& e) {
79628       {
79629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79630       };
79631     } catch (std::exception& e) {
79632       {
79633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79634       };
79635     } catch (...) {
79636       {
79637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79638       };
79639     }
79640   }
79641 }
79642
79643
79644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79645   void * jresult ;
79646   Dali::BaseHandle arg1 ;
79647   Dali::BaseHandle *argp1 ;
79648   Dali::Toolkit::TextLabel result;
79649
79650   argp1 = (Dali::BaseHandle *)jarg1;
79651   if (!argp1) {
79652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79653     return 0;
79654   }
79655   arg1 = *argp1;
79656   {
79657     try {
79658       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79659     } catch (std::out_of_range& e) {
79660       {
79661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79662       };
79663     } catch (std::exception& e) {
79664       {
79665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79666       };
79667     } catch (...) {
79668       {
79669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79670       };
79671     }
79672   }
79673   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79674   return jresult;
79675 }
79676
79677
79678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79679   void * jresult ;
79680   Dali::Toolkit::AccessibilityManager *result = 0 ;
79681
79682   {
79683     try {
79684       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79685     } catch (std::out_of_range& e) {
79686       {
79687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79688       };
79689     } catch (std::exception& e) {
79690       {
79691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79692       };
79693     } catch (...) {
79694       {
79695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79696       };
79697     }
79698   }
79699   jresult = (void *)result;
79700   return jresult;
79701 }
79702
79703
79704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79705   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79706
79707   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79708   {
79709     try {
79710       delete arg1;
79711     } catch (std::out_of_range& e) {
79712       {
79713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79714       };
79715     } catch (std::exception& e) {
79716       {
79717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79718       };
79719     } catch (...) {
79720       {
79721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79722       };
79723     }
79724   }
79725 }
79726
79727
79728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79729   void * jresult ;
79730   Dali::Toolkit::AccessibilityManager result;
79731
79732   {
79733     try {
79734       result = Dali::Toolkit::AccessibilityManager::Get();
79735     } catch (std::out_of_range& e) {
79736       {
79737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79738       };
79739     } catch (std::exception& e) {
79740       {
79741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79742       };
79743     } catch (...) {
79744       {
79745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79746       };
79747     }
79748   }
79749   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79750   return jresult;
79751 }
79752
79753
79754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79756   Dali::Actor arg2 ;
79757   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79758   std::string *arg4 = 0 ;
79759   Dali::Actor *argp2 ;
79760
79761   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79762   argp2 = (Dali::Actor *)jarg2;
79763   if (!argp2) {
79764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79765     return ;
79766   }
79767   arg2 = *argp2;
79768   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79769   if (!jarg4) {
79770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79771     return ;
79772   }
79773   std::string arg4_str(jarg4);
79774   arg4 = &arg4_str;
79775   {
79776     try {
79777       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79778     } catch (std::out_of_range& e) {
79779       {
79780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79781       };
79782     } catch (std::exception& e) {
79783       {
79784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79785       };
79786     } catch (...) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79789       };
79790     }
79791   }
79792
79793   //argout typemap for const std::string&
79794
79795 }
79796
79797
79798 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79799   char * jresult ;
79800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79801   Dali::Actor arg2 ;
79802   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79803   Dali::Actor *argp2 ;
79804   std::string result;
79805
79806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79807   argp2 = (Dali::Actor *)jarg2;
79808   if (!argp2) {
79809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79810     return 0;
79811   }
79812   arg2 = *argp2;
79813   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79814   {
79815     try {
79816       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79817     } catch (std::out_of_range& e) {
79818       {
79819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79820       };
79821     } catch (std::exception& e) {
79822       {
79823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79824       };
79825     } catch (...) {
79826       {
79827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79828       };
79829     }
79830   }
79831   jresult = SWIG_csharp_string_callback((&result)->c_str());
79832   return jresult;
79833 }
79834
79835
79836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79838   Dali::Actor arg2 ;
79839   unsigned int arg3 ;
79840   Dali::Actor *argp2 ;
79841
79842   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79843   argp2 = (Dali::Actor *)jarg2;
79844   if (!argp2) {
79845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79846     return ;
79847   }
79848   arg2 = *argp2;
79849   arg3 = (unsigned int)jarg3;
79850   {
79851     try {
79852       (arg1)->SetFocusOrder(arg2,arg3);
79853     } catch (std::out_of_range& e) {
79854       {
79855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79856       };
79857     } catch (std::exception& e) {
79858       {
79859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79860       };
79861     } catch (...) {
79862       {
79863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79864       };
79865     }
79866   }
79867 }
79868
79869
79870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79871   unsigned int jresult ;
79872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79873   Dali::Actor arg2 ;
79874   Dali::Actor *argp2 ;
79875   unsigned int result;
79876
79877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79878   argp2 = (Dali::Actor *)jarg2;
79879   if (!argp2) {
79880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79881     return 0;
79882   }
79883   arg2 = *argp2;
79884   {
79885     try {
79886       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79887     } catch (std::out_of_range& e) {
79888       {
79889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79890       };
79891     } catch (std::exception& e) {
79892       {
79893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79894       };
79895     } catch (...) {
79896       {
79897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79898       };
79899     }
79900   }
79901   jresult = result;
79902   return jresult;
79903 }
79904
79905
79906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79907   unsigned int jresult ;
79908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79909   unsigned int result;
79910
79911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79912   {
79913     try {
79914       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79915     } catch (std::out_of_range& e) {
79916       {
79917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79918       };
79919     } catch (std::exception& e) {
79920       {
79921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79922       };
79923     } catch (...) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79926       };
79927     }
79928   }
79929   jresult = result;
79930   return jresult;
79931 }
79932
79933
79934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79935   void * jresult ;
79936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79937   unsigned int arg2 ;
79938   Dali::Actor result;
79939
79940   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79941   arg2 = (unsigned int)jarg2;
79942   {
79943     try {
79944       result = (arg1)->GetActorByFocusOrder(arg2);
79945     } catch (std::out_of_range& e) {
79946       {
79947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (std::exception& e) {
79950       {
79951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79952       };
79953     } catch (...) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79956       };
79957     }
79958   }
79959   jresult = new Dali::Actor((const Dali::Actor &)result);
79960   return jresult;
79961 }
79962
79963
79964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79965   unsigned int jresult ;
79966   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79967   Dali::Actor arg2 ;
79968   Dali::Actor *argp2 ;
79969   bool result;
79970
79971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79972   argp2 = (Dali::Actor *)jarg2;
79973   if (!argp2) {
79974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79975     return 0;
79976   }
79977   arg2 = *argp2;
79978   {
79979     try {
79980       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79981     } catch (std::out_of_range& e) {
79982       {
79983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (std::exception& e) {
79986       {
79987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79988       };
79989     } catch (...) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79992       };
79993     }
79994   }
79995   jresult = result;
79996   return jresult;
79997 }
79998
79999
80000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80001   void * jresult ;
80002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80003   Dali::Actor result;
80004
80005   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80006   {
80007     try {
80008       result = (arg1)->GetCurrentFocusActor();
80009     } catch (std::out_of_range& e) {
80010       {
80011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (std::exception& e) {
80014       {
80015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80020       };
80021     }
80022   }
80023   jresult = new Dali::Actor((const Dali::Actor &)result);
80024   return jresult;
80025 }
80026
80027
80028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80029   void * jresult ;
80030   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80031   Dali::Actor result;
80032
80033   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80034   {
80035     try {
80036       result = (arg1)->GetCurrentFocusGroup();
80037     } catch (std::out_of_range& e) {
80038       {
80039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80040       };
80041     } catch (std::exception& e) {
80042       {
80043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80044       };
80045     } catch (...) {
80046       {
80047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80048       };
80049     }
80050   }
80051   jresult = new Dali::Actor((const Dali::Actor &)result);
80052   return jresult;
80053 }
80054
80055
80056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80057   unsigned int jresult ;
80058   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80059   unsigned int result;
80060
80061   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80062   {
80063     try {
80064       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80065     } catch (std::out_of_range& e) {
80066       {
80067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80068       };
80069     } catch (std::exception& e) {
80070       {
80071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80072       };
80073     } catch (...) {
80074       {
80075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80076       };
80077     }
80078   }
80079   jresult = result;
80080   return jresult;
80081 }
80082
80083
80084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80085   unsigned int jresult ;
80086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80087   bool result;
80088
80089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80090   {
80091     try {
80092       result = (bool)(arg1)->MoveFocusForward();
80093     } catch (std::out_of_range& e) {
80094       {
80095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80096       };
80097     } catch (std::exception& e) {
80098       {
80099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80100       };
80101     } catch (...) {
80102       {
80103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80104       };
80105     }
80106   }
80107   jresult = result;
80108   return jresult;
80109 }
80110
80111
80112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80113   unsigned int jresult ;
80114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80115   bool result;
80116
80117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80118   {
80119     try {
80120       result = (bool)(arg1)->MoveFocusBackward();
80121     } catch (std::out_of_range& e) {
80122       {
80123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (std::exception& e) {
80126       {
80127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80128       };
80129     } catch (...) {
80130       {
80131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80132       };
80133     }
80134   }
80135   jresult = result;
80136   return jresult;
80137 }
80138
80139
80140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80141   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80142
80143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80144   {
80145     try {
80146       (arg1)->ClearFocus();
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (...) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80158       };
80159     }
80160   }
80161 }
80162
80163
80164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80165   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80166
80167   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80168   {
80169     try {
80170       (arg1)->Reset();
80171     } catch (std::out_of_range& e) {
80172       {
80173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80174       };
80175     } catch (std::exception& e) {
80176       {
80177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80178       };
80179     } catch (...) {
80180       {
80181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80182       };
80183     }
80184   }
80185 }
80186
80187
80188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80190   Dali::Actor arg2 ;
80191   bool arg3 ;
80192   Dali::Actor *argp2 ;
80193
80194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80195   argp2 = (Dali::Actor *)jarg2;
80196   if (!argp2) {
80197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80198     return ;
80199   }
80200   arg2 = *argp2;
80201   arg3 = jarg3 ? true : false;
80202   {
80203     try {
80204       (arg1)->SetFocusGroup(arg2,arg3);
80205     } catch (std::out_of_range& e) {
80206       {
80207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80208       };
80209     } catch (std::exception& e) {
80210       {
80211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (...) {
80214       {
80215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80216       };
80217     }
80218   }
80219 }
80220
80221
80222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80223   unsigned int jresult ;
80224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80225   Dali::Actor arg2 ;
80226   Dali::Actor *argp2 ;
80227   bool result;
80228
80229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80230   argp2 = (Dali::Actor *)jarg2;
80231   if (!argp2) {
80232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80233     return 0;
80234   }
80235   arg2 = *argp2;
80236   {
80237     try {
80238       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80239     } catch (std::out_of_range& e) {
80240       {
80241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80242       };
80243     } catch (std::exception& e) {
80244       {
80245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80246       };
80247     } catch (...) {
80248       {
80249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80250       };
80251     }
80252   }
80253   jresult = result;
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80260   bool arg2 ;
80261
80262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80263   arg2 = jarg2 ? true : false;
80264   {
80265     try {
80266       (arg1)->SetGroupMode(arg2);
80267     } catch (std::out_of_range& e) {
80268       {
80269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80270       };
80271     } catch (std::exception& e) {
80272       {
80273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80274       };
80275     } catch (...) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80278       };
80279     }
80280   }
80281 }
80282
80283
80284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80285   unsigned int jresult ;
80286   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80287   bool result;
80288
80289   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80290   {
80291     try {
80292       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80293     } catch (std::out_of_range& e) {
80294       {
80295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80296       };
80297     } catch (std::exception& e) {
80298       {
80299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80304       };
80305     }
80306   }
80307   jresult = result;
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80314   bool arg2 ;
80315
80316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80317   arg2 = jarg2 ? true : false;
80318   {
80319     try {
80320       (arg1)->SetWrapMode(arg2);
80321     } catch (std::out_of_range& e) {
80322       {
80323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80324       };
80325     } catch (std::exception& e) {
80326       {
80327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80328       };
80329     } catch (...) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80332       };
80333     }
80334   }
80335 }
80336
80337
80338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80339   unsigned int jresult ;
80340   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80341   bool result;
80342
80343   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80344   {
80345     try {
80346       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80347     } catch (std::out_of_range& e) {
80348       {
80349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80350       };
80351     } catch (std::exception& e) {
80352       {
80353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80354       };
80355     } catch (...) {
80356       {
80357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80358       };
80359     }
80360   }
80361   jresult = result;
80362   return jresult;
80363 }
80364
80365
80366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80368   Dali::Actor arg2 ;
80369   Dali::Actor *argp2 ;
80370
80371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80372   argp2 = (Dali::Actor *)jarg2;
80373   if (!argp2) {
80374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80375     return ;
80376   }
80377   arg2 = *argp2;
80378   {
80379     try {
80380       (arg1)->SetFocusIndicatorActor(arg2);
80381     } catch (std::out_of_range& e) {
80382       {
80383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80384       };
80385     } catch (std::exception& e) {
80386       {
80387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80392       };
80393     }
80394   }
80395 }
80396
80397
80398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80399   void * jresult ;
80400   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80401   Dali::Actor result;
80402
80403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80404   {
80405     try {
80406       result = (arg1)->GetFocusIndicatorActor();
80407     } catch (std::out_of_range& e) {
80408       {
80409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80410       };
80411     } catch (std::exception& e) {
80412       {
80413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80414       };
80415     } catch (...) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80418       };
80419     }
80420   }
80421   jresult = new Dali::Actor((const Dali::Actor &)result);
80422   return jresult;
80423 }
80424
80425
80426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80427   void * jresult ;
80428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80429   Dali::Actor arg2 ;
80430   Dali::Actor *argp2 ;
80431   Dali::Actor result;
80432
80433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80434   argp2 = (Dali::Actor *)jarg2;
80435   if (!argp2) {
80436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80437     return 0;
80438   }
80439   arg2 = *argp2;
80440   {
80441     try {
80442       result = (arg1)->GetFocusGroup(arg2);
80443     } catch (std::out_of_range& e) {
80444       {
80445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80446       };
80447     } catch (std::exception& e) {
80448       {
80449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80450       };
80451     } catch (...) {
80452       {
80453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80454       };
80455     }
80456   }
80457   jresult = new Dali::Actor((const Dali::Actor &)result);
80458   return jresult;
80459 }
80460
80461
80462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80463   void * jresult ;
80464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80465   Dali::Vector2 result;
80466
80467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80468   {
80469     try {
80470       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80471     } catch (std::out_of_range& e) {
80472       {
80473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (std::exception& e) {
80476       {
80477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80478       };
80479     } catch (...) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80482       };
80483     }
80484   }
80485   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80486   return jresult;
80487 }
80488
80489
80490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80491   void * jresult ;
80492   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80493   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80494
80495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80496   {
80497     try {
80498       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80499     } catch (std::out_of_range& e) {
80500       {
80501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80502       };
80503     } catch (std::exception& e) {
80504       {
80505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80506       };
80507     } catch (...) {
80508       {
80509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80510       };
80511     }
80512   }
80513   jresult = (void *)result;
80514   return jresult;
80515 }
80516
80517
80518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80519   void * jresult ;
80520   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80521   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80522
80523   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80524   {
80525     try {
80526       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80527     } catch (std::out_of_range& e) {
80528       {
80529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80530       };
80531     } catch (std::exception& e) {
80532       {
80533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80538       };
80539     }
80540   }
80541   jresult = (void *)result;
80542   return jresult;
80543 }
80544
80545
80546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80547   void * jresult ;
80548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80549   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80550
80551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80552   {
80553     try {
80554       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80555     } catch (std::out_of_range& e) {
80556       {
80557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80558       };
80559     } catch (std::exception& e) {
80560       {
80561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80566       };
80567     }
80568   }
80569   jresult = (void *)result;
80570   return jresult;
80571 }
80572
80573
80574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80575   void * jresult ;
80576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80577   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80578
80579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80580   {
80581     try {
80582       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80583     } catch (std::out_of_range& e) {
80584       {
80585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80586       };
80587     } catch (std::exception& e) {
80588       {
80589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (...) {
80592       {
80593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80594       };
80595     }
80596   }
80597   jresult = (void *)result;
80598   return jresult;
80599 }
80600
80601
80602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80603   void * jresult ;
80604   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80605   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80606
80607   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80608   {
80609     try {
80610       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80611     } catch (std::out_of_range& e) {
80612       {
80613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80614       };
80615     } catch (std::exception& e) {
80616       {
80617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80618       };
80619     } catch (...) {
80620       {
80621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80622       };
80623     }
80624   }
80625   jresult = (void *)result;
80626   return jresult;
80627 }
80628
80629
80630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80631   void * jresult ;
80632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80633   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80634
80635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80636   {
80637     try {
80638       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80639     } catch (std::out_of_range& e) {
80640       {
80641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80642       };
80643     } catch (std::exception& e) {
80644       {
80645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (...) {
80648       {
80649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80650       };
80651     }
80652   }
80653   jresult = (void *)result;
80654   return jresult;
80655 }
80656
80657
80658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80659   void * jresult ;
80660   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80661   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80662
80663   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80664   {
80665     try {
80666       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80667     } catch (std::out_of_range& e) {
80668       {
80669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80670       };
80671     } catch (std::exception& e) {
80672       {
80673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80674       };
80675     } catch (...) {
80676       {
80677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80678       };
80679     }
80680   }
80681   jresult = (void *)result;
80682   return jresult;
80683 }
80684
80685
80686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80687   void * jresult ;
80688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80689   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80690
80691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80692   {
80693     try {
80694       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80695     } catch (std::out_of_range& e) {
80696       {
80697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80698       };
80699     } catch (std::exception& e) {
80700       {
80701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80702       };
80703     } catch (...) {
80704       {
80705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80706       };
80707     }
80708   }
80709   jresult = (void *)result;
80710   return jresult;
80711 }
80712
80713
80714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80715   void * jresult ;
80716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80717   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80718
80719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80720   {
80721     try {
80722       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80723     } catch (std::out_of_range& e) {
80724       {
80725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80726       };
80727     } catch (std::exception& e) {
80728       {
80729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80730       };
80731     } catch (...) {
80732       {
80733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80734       };
80735     }
80736   }
80737   jresult = (void *)result;
80738   return jresult;
80739 }
80740
80741
80742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80743   void * jresult ;
80744   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80745   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80746
80747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80748   {
80749     try {
80750       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80751     } catch (std::out_of_range& e) {
80752       {
80753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80754       };
80755     } catch (std::exception& e) {
80756       {
80757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80758       };
80759     } catch (...) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80762       };
80763     }
80764   }
80765   jresult = (void *)result;
80766   return jresult;
80767 }
80768
80769
80770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80771   void * jresult ;
80772   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80773   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80774
80775   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80776   {
80777     try {
80778       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80779     } catch (std::out_of_range& e) {
80780       {
80781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80782       };
80783     } catch (std::exception& e) {
80784       {
80785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80786       };
80787     } catch (...) {
80788       {
80789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80790       };
80791     }
80792   }
80793   jresult = (void *)result;
80794   return jresult;
80795 }
80796
80797
80798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80799   void * jresult ;
80800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80801   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80802
80803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80804   {
80805     try {
80806       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80807     } catch (std::out_of_range& e) {
80808       {
80809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80810       };
80811     } catch (std::exception& e) {
80812       {
80813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80814       };
80815     } catch (...) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80818       };
80819     }
80820   }
80821   jresult = (void *)result;
80822   return jresult;
80823 }
80824
80825
80826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80827   void * jresult ;
80828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80829   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80830
80831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80832   {
80833     try {
80834       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80835     } catch (std::out_of_range& e) {
80836       {
80837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80838       };
80839     } catch (std::exception& e) {
80840       {
80841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80842       };
80843     } catch (...) {
80844       {
80845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80846       };
80847     }
80848   }
80849   jresult = (void *)result;
80850   return jresult;
80851 }
80852
80853
80854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80855   void * jresult ;
80856   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80857   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80858
80859   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80860   {
80861     try {
80862       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80863     } catch (std::out_of_range& e) {
80864       {
80865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80866       };
80867     } catch (std::exception& e) {
80868       {
80869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80870       };
80871     } catch (...) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80874       };
80875     }
80876   }
80877   jresult = (void *)result;
80878   return jresult;
80879 }
80880
80881
80882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80883   void * jresult ;
80884   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80885   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80886
80887   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80888   {
80889     try {
80890       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80891     } catch (std::out_of_range& e) {
80892       {
80893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80894       };
80895     } catch (std::exception& e) {
80896       {
80897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80898       };
80899     } catch (...) {
80900       {
80901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80902       };
80903     }
80904   }
80905   jresult = (void *)result;
80906   return jresult;
80907 }
80908
80909
80910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80911   void * jresult ;
80912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80913   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80914
80915   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80916   {
80917     try {
80918       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (...) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80930       };
80931     }
80932   }
80933   jresult = (void *)result;
80934   return jresult;
80935 }
80936
80937
80938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80939   void * jresult ;
80940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80941   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80942
80943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80944   {
80945     try {
80946       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80947     } catch (std::out_of_range& e) {
80948       {
80949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (std::exception& e) {
80952       {
80953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80954       };
80955     } catch (...) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80958       };
80959     }
80960   }
80961   jresult = (void *)result;
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80967   void * jresult ;
80968   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80969   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80970
80971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80972   {
80973     try {
80974       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (...) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80986       };
80987     }
80988   }
80989   jresult = (void *)result;
80990   return jresult;
80991 }
80992
80993
80994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80995   void * jresult ;
80996   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80997   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80998
80999   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81000   {
81001     try {
81002       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81003     } catch (std::out_of_range& e) {
81004       {
81005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (std::exception& e) {
81008       {
81009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81010       };
81011     } catch (...) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81014       };
81015     }
81016   }
81017   jresult = (void *)result;
81018   return jresult;
81019 }
81020
81021
81022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81023   void * jresult ;
81024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81025   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81026
81027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81028   {
81029     try {
81030       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81031     } catch (std::out_of_range& e) {
81032       {
81033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81034       };
81035     } catch (std::exception& e) {
81036       {
81037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81038       };
81039     } catch (...) {
81040       {
81041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81042       };
81043     }
81044   }
81045   jresult = (void *)result;
81046   return jresult;
81047 }
81048
81049
81050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81051   void * jresult ;
81052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81053   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81054
81055   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81056   {
81057     try {
81058       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (...) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81070       };
81071     }
81072   }
81073   jresult = (void *)result;
81074   return jresult;
81075 }
81076
81077
81078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81079   void * jresult ;
81080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81081   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81082
81083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81084   {
81085     try {
81086       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81094       };
81095     } catch (...) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81098       };
81099     }
81100   }
81101   jresult = (void *)result;
81102   return jresult;
81103 }
81104
81105
81106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81107   void * jresult ;
81108   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81109   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81110
81111   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81112   {
81113     try {
81114       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81115     } catch (std::out_of_range& e) {
81116       {
81117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81118       };
81119     } catch (std::exception& e) {
81120       {
81121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81122       };
81123     } catch (...) {
81124       {
81125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81126       };
81127     }
81128   }
81129   jresult = (void *)result;
81130   return jresult;
81131 }
81132
81133
81134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81135   void * jresult ;
81136   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81137   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81138
81139   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81140   {
81141     try {
81142       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81143     } catch (std::out_of_range& e) {
81144       {
81145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81146       };
81147     } catch (std::exception& e) {
81148       {
81149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81150       };
81151     } catch (...) {
81152       {
81153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81154       };
81155     }
81156   }
81157   jresult = (void *)result;
81158   return jresult;
81159 }
81160
81161
81162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81163   void * jresult ;
81164   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81165   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81166
81167   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81168   {
81169     try {
81170       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81171     } catch (std::out_of_range& e) {
81172       {
81173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81174       };
81175     } catch (std::exception& e) {
81176       {
81177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81178       };
81179     } catch (...) {
81180       {
81181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81182       };
81183     }
81184   }
81185   jresult = (void *)result;
81186   return jresult;
81187 }
81188
81189
81190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81191   void * jresult ;
81192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81193   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81194
81195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81196   {
81197     try {
81198       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81199     } catch (std::out_of_range& e) {
81200       {
81201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81202       };
81203     } catch (std::exception& e) {
81204       {
81205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81206       };
81207     } catch (...) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81210       };
81211     }
81212   }
81213   jresult = (void *)result;
81214   return jresult;
81215 }
81216
81217
81218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81219   void * jresult ;
81220   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81221   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81222
81223   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81224   {
81225     try {
81226       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81227     } catch (std::out_of_range& e) {
81228       {
81229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (std::exception& e) {
81232       {
81233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (...) {
81236       {
81237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81238       };
81239     }
81240   }
81241   jresult = (void *)result;
81242   return jresult;
81243 }
81244
81245
81246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81247   void * jresult ;
81248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81249   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81250
81251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81252   {
81253     try {
81254       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81255     } catch (std::out_of_range& e) {
81256       {
81257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (std::exception& e) {
81260       {
81261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81262       };
81263     } catch (...) {
81264       {
81265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81266       };
81267     }
81268   }
81269   jresult = (void *)result;
81270   return jresult;
81271 }
81272
81273
81274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81275   void * jresult ;
81276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81277   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81278
81279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81280   {
81281     try {
81282       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81283     } catch (std::out_of_range& e) {
81284       {
81285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81286       };
81287     } catch (std::exception& e) {
81288       {
81289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81290       };
81291     } catch (...) {
81292       {
81293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81294       };
81295     }
81296   }
81297   jresult = (void *)result;
81298   return jresult;
81299 }
81300
81301
81302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81303   void * jresult ;
81304   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81305   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81306
81307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81308   {
81309     try {
81310       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81311     } catch (std::out_of_range& e) {
81312       {
81313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81314       };
81315     } catch (std::exception& e) {
81316       {
81317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81318       };
81319     } catch (...) {
81320       {
81321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81322       };
81323     }
81324   }
81325   jresult = (void *)result;
81326   return jresult;
81327 }
81328
81329
81330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81331   void * jresult ;
81332   Dali::Toolkit::StyleManager *result = 0 ;
81333
81334   {
81335     try {
81336       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (...) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81348       };
81349     }
81350   }
81351   jresult = (void *)result;
81352   return jresult;
81353 }
81354
81355
81356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81357   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81358
81359   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81360   {
81361     try {
81362       delete arg1;
81363     } catch (std::out_of_range& e) {
81364       {
81365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81366       };
81367     } catch (std::exception& e) {
81368       {
81369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81370       };
81371     } catch (...) {
81372       {
81373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81374       };
81375     }
81376   }
81377 }
81378
81379
81380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81381   void * jresult ;
81382   Dali::Toolkit::StyleManager result;
81383
81384   {
81385     try {
81386       result = Dali::Toolkit::StyleManager::Get();
81387     } catch (std::out_of_range& e) {
81388       {
81389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81390       };
81391     } catch (std::exception& e) {
81392       {
81393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81394       };
81395     } catch (...) {
81396       {
81397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81398       };
81399     }
81400   }
81401   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81402   return jresult;
81403 }
81404
81405
81406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81407   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81408   std::string *arg2 = 0 ;
81409
81410   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81411   if (!jarg2) {
81412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81413     return ;
81414   }
81415   std::string arg2_str(jarg2);
81416   arg2 = &arg2_str;
81417   {
81418     try {
81419       (arg1)->ApplyTheme((std::string const &)*arg2);
81420     } catch (std::out_of_range& e) {
81421       {
81422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81423       };
81424     } catch (std::exception& e) {
81425       {
81426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81427       };
81428     } catch (...) {
81429       {
81430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81431       };
81432     }
81433   }
81434
81435   //argout typemap for const std::string&
81436
81437 }
81438
81439
81440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81441   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81442
81443   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81444   {
81445     try {
81446       (arg1)->ApplyDefaultTheme();
81447     } catch (std::out_of_range& e) {
81448       {
81449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81450       };
81451     } catch (std::exception& e) {
81452       {
81453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81458       };
81459     }
81460   }
81461 }
81462
81463
81464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81465   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81466   std::string *arg2 = 0 ;
81467   Dali::Property::Value *arg3 = 0 ;
81468
81469   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81470   if (!jarg2) {
81471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81472     return ;
81473   }
81474   std::string arg2_str(jarg2);
81475   arg2 = &arg2_str;
81476   arg3 = (Dali::Property::Value *)jarg3;
81477   if (!arg3) {
81478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81479     return ;
81480   }
81481   {
81482     try {
81483       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81484     } catch (std::out_of_range& e) {
81485       {
81486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81487       };
81488     } catch (std::exception& e) {
81489       {
81490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81491       };
81492     } catch (...) {
81493       {
81494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81495       };
81496     }
81497   }
81498
81499   //argout typemap for const std::string&
81500
81501 }
81502
81503
81504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81505   unsigned int jresult ;
81506   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81507   std::string *arg2 = 0 ;
81508   Dali::Property::Value *arg3 = 0 ;
81509   bool result;
81510
81511   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81512   if (!jarg2) {
81513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81514     return 0;
81515   }
81516   std::string arg2_str(jarg2);
81517   arg2 = &arg2_str;
81518   arg3 = (Dali::Property::Value *)jarg3;
81519   if (!arg3) {
81520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81521     return 0;
81522   }
81523   {
81524     try {
81525       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81526     } catch (std::out_of_range& e) {
81527       {
81528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81529       };
81530     } catch (std::exception& e) {
81531       {
81532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81533       };
81534     } catch (...) {
81535       {
81536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81537       };
81538     }
81539   }
81540   jresult = result;
81541
81542   //argout typemap for const std::string&
81543
81544   return jresult;
81545 }
81546
81547
81548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81549   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81550   Dali::Toolkit::Control arg2 ;
81551   std::string *arg3 = 0 ;
81552   std::string *arg4 = 0 ;
81553   Dali::Toolkit::Control *argp2 ;
81554
81555   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81556   argp2 = (Dali::Toolkit::Control *)jarg2;
81557   if (!argp2) {
81558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81559     return ;
81560   }
81561   arg2 = *argp2;
81562   if (!jarg3) {
81563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81564     return ;
81565   }
81566   std::string arg3_str(jarg3);
81567   arg3 = &arg3_str;
81568   if (!jarg4) {
81569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81570     return ;
81571   }
81572   std::string arg4_str(jarg4);
81573   arg4 = &arg4_str;
81574   {
81575     try {
81576       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81577     } catch (std::out_of_range& e) {
81578       {
81579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81580       };
81581     } catch (std::exception& e) {
81582       {
81583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81584       };
81585     } catch (...) {
81586       {
81587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81588       };
81589     }
81590   }
81591
81592   //argout typemap for const std::string&
81593
81594
81595   //argout typemap for const std::string&
81596
81597 }
81598
81599
81600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81601   void * jresult ;
81602   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81603   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81604
81605   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81606   {
81607     try {
81608       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81609     } catch (std::out_of_range& e) {
81610       {
81611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81612       };
81613     } catch (std::exception& e) {
81614       {
81615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81616       };
81617     } catch (...) {
81618       {
81619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81620       };
81621     }
81622   }
81623   jresult = (void *)result;
81624   return jresult;
81625 }
81626
81627
81628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81629   int jresult ;
81630   int result;
81631
81632   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81633   jresult = (int)result;
81634   return jresult;
81635 }
81636
81637
81638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81639   int jresult ;
81640   int result;
81641
81642   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81643   jresult = (int)result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81649   int jresult ;
81650   int result;
81651
81652   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81653   jresult = (int)result;
81654   return jresult;
81655 }
81656
81657
81658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81659   int jresult ;
81660   int result;
81661
81662   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81663   jresult = (int)result;
81664   return jresult;
81665 }
81666
81667
81668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81669   int jresult ;
81670   int result;
81671
81672   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81673   jresult = (int)result;
81674   return jresult;
81675 }
81676
81677
81678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81679   int jresult ;
81680   int result;
81681
81682   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81683   jresult = (int)result;
81684   return jresult;
81685 }
81686
81687
81688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81689   int jresult ;
81690   int result;
81691
81692   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81693   jresult = (int)result;
81694   return jresult;
81695 }
81696
81697
81698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81699   int jresult ;
81700   int result;
81701
81702   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81703   jresult = (int)result;
81704   return jresult;
81705 }
81706
81707
81708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81709   int jresult ;
81710   int result;
81711
81712   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81713   jresult = (int)result;
81714   return jresult;
81715 }
81716
81717
81718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81719   int jresult ;
81720   int result;
81721
81722   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81723   jresult = (int)result;
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81729   int jresult ;
81730   int result;
81731
81732   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81733   jresult = (int)result;
81734   return jresult;
81735 }
81736
81737
81738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81739   int jresult ;
81740   int result;
81741
81742   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81743   jresult = (int)result;
81744   return jresult;
81745 }
81746
81747
81748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81749   int jresult ;
81750   int result;
81751
81752   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81753   jresult = (int)result;
81754   return jresult;
81755 }
81756
81757
81758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81759   int jresult ;
81760   int result;
81761
81762   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81763   jresult = (int)result;
81764   return jresult;
81765 }
81766
81767
81768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81769   int jresult ;
81770   int result;
81771
81772   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81773   jresult = (int)result;
81774   return jresult;
81775 }
81776
81777
81778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81779   void * jresult ;
81780   Dali::Toolkit::Slider::Property *result = 0 ;
81781
81782   {
81783     try {
81784       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81785     } catch (std::out_of_range& e) {
81786       {
81787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (std::exception& e) {
81790       {
81791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81792       };
81793     } catch (...) {
81794       {
81795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81796       };
81797     }
81798   }
81799   jresult = (void *)result;
81800   return jresult;
81801 }
81802
81803
81804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81805   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81806
81807   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81808   {
81809     try {
81810       delete arg1;
81811     } catch (std::out_of_range& e) {
81812       {
81813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81814       };
81815     } catch (std::exception& e) {
81816       {
81817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81818       };
81819     } catch (...) {
81820       {
81821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81822       };
81823     }
81824   }
81825 }
81826
81827
81828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81829   void * jresult ;
81830   Dali::Toolkit::Slider result;
81831
81832   {
81833     try {
81834       result = Dali::Toolkit::Slider::New();
81835     } catch (std::out_of_range& e) {
81836       {
81837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (std::exception& e) {
81840       {
81841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81842       };
81843     } catch (...) {
81844       {
81845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81846       };
81847     }
81848   }
81849   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81850   return jresult;
81851 }
81852
81853
81854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81855   void * jresult ;
81856   Dali::Toolkit::Slider *result = 0 ;
81857
81858   {
81859     try {
81860       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81861     } catch (std::out_of_range& e) {
81862       {
81863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81864       };
81865     } catch (std::exception& e) {
81866       {
81867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81868       };
81869     } catch (...) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81872       };
81873     }
81874   }
81875   jresult = (void *)result;
81876   return jresult;
81877 }
81878
81879
81880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81881   void * jresult ;
81882   Dali::Toolkit::Slider *arg1 = 0 ;
81883   Dali::Toolkit::Slider *result = 0 ;
81884
81885   arg1 = (Dali::Toolkit::Slider *)jarg1;
81886   if (!arg1) {
81887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81888     return 0;
81889   }
81890   {
81891     try {
81892       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81900       };
81901     } catch (...) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81904       };
81905     }
81906   }
81907   jresult = (void *)result;
81908   return jresult;
81909 }
81910
81911
81912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81913   void * jresult ;
81914   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81915   Dali::Toolkit::Slider *arg2 = 0 ;
81916   Dali::Toolkit::Slider *result = 0 ;
81917
81918   arg1 = (Dali::Toolkit::Slider *)jarg1;
81919   arg2 = (Dali::Toolkit::Slider *)jarg2;
81920   if (!arg2) {
81921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81922     return 0;
81923   }
81924   {
81925     try {
81926       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81927     } catch (std::out_of_range& e) {
81928       {
81929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81930       };
81931     } catch (std::exception& e) {
81932       {
81933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81938       };
81939     }
81940   }
81941   jresult = (void *)result;
81942   return jresult;
81943 }
81944
81945
81946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81947   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81948
81949   arg1 = (Dali::Toolkit::Slider *)jarg1;
81950   {
81951     try {
81952       delete arg1;
81953     } catch (std::out_of_range& e) {
81954       {
81955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81956       };
81957     } catch (std::exception& e) {
81958       {
81959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81964       };
81965     }
81966   }
81967 }
81968
81969
81970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81971   void * jresult ;
81972   Dali::BaseHandle arg1 ;
81973   Dali::BaseHandle *argp1 ;
81974   Dali::Toolkit::Slider result;
81975
81976   argp1 = (Dali::BaseHandle *)jarg1;
81977   if (!argp1) {
81978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81979     return 0;
81980   }
81981   arg1 = *argp1;
81982   {
81983     try {
81984       result = Dali::Toolkit::Slider::DownCast(arg1);
81985     } catch (std::out_of_range& e) {
81986       {
81987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (std::exception& e) {
81990       {
81991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81992       };
81993     } catch (...) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81996       };
81997     }
81998   }
81999   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82000   return jresult;
82001 }
82002
82003
82004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82005   void * jresult ;
82006   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82007   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82008
82009   arg1 = (Dali::Toolkit::Slider *)jarg1;
82010   {
82011     try {
82012       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82013     } catch (std::out_of_range& e) {
82014       {
82015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82016       };
82017     } catch (std::exception& e) {
82018       {
82019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82020       };
82021     } catch (...) {
82022       {
82023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82024       };
82025     }
82026   }
82027   jresult = (void *)result;
82028   return jresult;
82029 }
82030
82031
82032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82033   void * jresult ;
82034   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82035   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82036
82037   arg1 = (Dali::Toolkit::Slider *)jarg1;
82038   {
82039     try {
82040       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82052       };
82053     }
82054   }
82055   jresult = (void *)result;
82056   return jresult;
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82061   void * jresult ;
82062   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82063   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82064
82065   arg1 = (Dali::Toolkit::Slider *)jarg1;
82066   {
82067     try {
82068       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (...) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82080       };
82081     }
82082   }
82083   jresult = (void *)result;
82084   return jresult;
82085 }
82086
82087
82088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82089   int jresult ;
82090   int result;
82091
82092   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82093   jresult = (int)result;
82094   return jresult;
82095 }
82096
82097
82098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82099   int jresult ;
82100   int result;
82101
82102   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82103   jresult = (int)result;
82104   return jresult;
82105 }
82106
82107
82108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82109   int jresult ;
82110   int result;
82111
82112   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82113   jresult = (int)result;
82114   return jresult;
82115 }
82116
82117
82118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82119   int jresult ;
82120   int result;
82121
82122   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82123   jresult = (int)result;
82124   return jresult;
82125 }
82126
82127
82128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82129   void * jresult ;
82130   Dali::Toolkit::VideoView::Property *result = 0 ;
82131
82132   {
82133     try {
82134       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82135     } catch (std::out_of_range& e) {
82136       {
82137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82138       };
82139     } catch (std::exception& e) {
82140       {
82141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82142       };
82143     } catch (...) {
82144       {
82145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82146       };
82147     }
82148   }
82149   jresult = (void *)result;
82150   return jresult;
82151 }
82152
82153
82154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82155   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82156
82157   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82158   {
82159     try {
82160       delete arg1;
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82172       };
82173     }
82174   }
82175 }
82176
82177
82178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82179   void * jresult ;
82180   Dali::Toolkit::VideoView result;
82181
82182   {
82183     try {
82184       result = Dali::Toolkit::VideoView::New();
82185     } catch (std::out_of_range& e) {
82186       {
82187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82188       };
82189     } catch (std::exception& e) {
82190       {
82191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82196       };
82197     }
82198   }
82199   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82200   return jresult;
82201 }
82202
82203
82204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82205   void * jresult ;
82206   std::string *arg1 = 0 ;
82207   Dali::Toolkit::VideoView result;
82208
82209   if (!jarg1) {
82210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82211     return 0;
82212   }
82213   std::string arg1_str(jarg1);
82214   arg1 = &arg1_str;
82215   {
82216     try {
82217       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82218     } catch (std::out_of_range& e) {
82219       {
82220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82221       };
82222     } catch (std::exception& e) {
82223       {
82224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82225       };
82226     } catch (...) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82229       };
82230     }
82231   }
82232   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82233
82234   //argout typemap for const std::string&
82235
82236   return jresult;
82237 }
82238
82239
82240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82241   void * jresult ;
82242   Dali::Toolkit::VideoView *result = 0 ;
82243
82244   {
82245     try {
82246       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82247     } catch (std::out_of_range& e) {
82248       {
82249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82250       };
82251     } catch (std::exception& e) {
82252       {
82253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (...) {
82256       {
82257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82258       };
82259     }
82260   }
82261   jresult = (void *)result;
82262   return jresult;
82263 }
82264
82265
82266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82267   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82268
82269   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82270   {
82271     try {
82272       delete arg1;
82273     } catch (std::out_of_range& e) {
82274       {
82275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82276       };
82277     } catch (std::exception& e) {
82278       {
82279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82280       };
82281     } catch (...) {
82282       {
82283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82284       };
82285     }
82286   }
82287 }
82288
82289
82290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82291   void * jresult ;
82292   Dali::Toolkit::VideoView *arg1 = 0 ;
82293   Dali::Toolkit::VideoView *result = 0 ;
82294
82295   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82296   if (!arg1) {
82297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82298     return 0;
82299   }
82300   {
82301     try {
82302       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82303     } catch (std::out_of_range& e) {
82304       {
82305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82306       };
82307     } catch (std::exception& e) {
82308       {
82309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82310       };
82311     } catch (...) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82314       };
82315     }
82316   }
82317   jresult = (void *)result;
82318   return jresult;
82319 }
82320
82321
82322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82323   void * jresult ;
82324   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82325   Dali::Toolkit::VideoView *arg2 = 0 ;
82326   Dali::Toolkit::VideoView *result = 0 ;
82327
82328   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82329   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82330   if (!arg2) {
82331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82332     return 0;
82333   }
82334   {
82335     try {
82336       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82337     } catch (std::out_of_range& e) {
82338       {
82339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (std::exception& e) {
82342       {
82343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82348       };
82349     }
82350   }
82351   jresult = (void *)result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82357   void * jresult ;
82358   Dali::BaseHandle arg1 ;
82359   Dali::BaseHandle *argp1 ;
82360   Dali::Toolkit::VideoView result;
82361
82362   argp1 = (Dali::BaseHandle *)jarg1;
82363   if (!argp1) {
82364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82365     return 0;
82366   }
82367   arg1 = *argp1;
82368   {
82369     try {
82370       result = Dali::Toolkit::VideoView::DownCast(arg1);
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (...) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82382       };
82383     }
82384   }
82385   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82386   return jresult;
82387 }
82388
82389
82390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82391   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82392
82393   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82394   {
82395     try {
82396       (arg1)->Play();
82397     } catch (std::out_of_range& e) {
82398       {
82399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82400       };
82401     } catch (std::exception& e) {
82402       {
82403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82404       };
82405     } catch (...) {
82406       {
82407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82408       };
82409     }
82410   }
82411 }
82412
82413
82414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82415   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82416
82417   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82418   {
82419     try {
82420       (arg1)->Pause();
82421     } catch (std::out_of_range& e) {
82422       {
82423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82424       };
82425     } catch (std::exception& e) {
82426       {
82427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82428       };
82429     } catch (...) {
82430       {
82431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82432       };
82433     }
82434   }
82435 }
82436
82437
82438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82439   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82440
82441   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82442   {
82443     try {
82444       (arg1)->Stop();
82445     } catch (std::out_of_range& e) {
82446       {
82447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82448       };
82449     } catch (std::exception& e) {
82450       {
82451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82452       };
82453     } catch (...) {
82454       {
82455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82456       };
82457     }
82458   }
82459 }
82460
82461
82462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82463   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82464   int arg2 ;
82465
82466   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82467   arg2 = (int)jarg2;
82468   {
82469     try {
82470       (arg1)->Forward(arg2);
82471     } catch (std::out_of_range& e) {
82472       {
82473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82474       };
82475     } catch (std::exception& e) {
82476       {
82477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82478       };
82479     } catch (...) {
82480       {
82481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82482       };
82483     }
82484   }
82485 }
82486
82487
82488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82489   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82490   int arg2 ;
82491
82492   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82493   arg2 = (int)jarg2;
82494   {
82495     try {
82496       (arg1)->Backward(arg2);
82497     } catch (std::out_of_range& e) {
82498       {
82499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (std::exception& e) {
82502       {
82503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (...) {
82506       {
82507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82508       };
82509     }
82510   }
82511 }
82512
82513
82514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82515   void * jresult ;
82516   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82517   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82518
82519   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82520   {
82521     try {
82522       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82523     } catch (std::out_of_range& e) {
82524       {
82525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82526       };
82527     } catch (std::exception& e) {
82528       {
82529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82530       };
82531     } catch (...) {
82532       {
82533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82534       };
82535     }
82536   }
82537   jresult = (void *)result;
82538   return jresult;
82539 }
82540
82541
82542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82543   int jresult ;
82544   int result;
82545
82546   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82547   jresult = (int)result;
82548   return jresult;
82549 }
82550
82551
82552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82553   int jresult ;
82554   int result;
82555
82556   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82557   jresult = (int)result;
82558   return jresult;
82559 }
82560
82561
82562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82563   int jresult ;
82564   int result;
82565
82566   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82567   jresult = (int)result;
82568   return jresult;
82569 }
82570
82571
82572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82573   int jresult ;
82574   int result;
82575
82576   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82577   jresult = (int)result;
82578   return jresult;
82579 }
82580
82581
82582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82583   int jresult ;
82584   int result;
82585
82586   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82587   jresult = (int)result;
82588   return jresult;
82589 }
82590
82591
82592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82593   int jresult ;
82594   int result;
82595
82596   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82597   jresult = (int)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82603   int jresult ;
82604   int result;
82605
82606   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82607   jresult = (int)result;
82608   return jresult;
82609 }
82610
82611
82612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82613   int jresult ;
82614   int result;
82615
82616   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82617   jresult = (int)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82623   int jresult ;
82624   int result;
82625
82626   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82627   jresult = (int)result;
82628   return jresult;
82629 }
82630
82631
82632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82633   int jresult ;
82634   int result;
82635
82636   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82637   jresult = (int)result;
82638   return jresult;
82639 }
82640
82641
82642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82643   int jresult ;
82644   int result;
82645
82646   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82647   jresult = (int)result;
82648   return jresult;
82649 }
82650
82651
82652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82653   int jresult ;
82654   int result;
82655
82656   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82657   jresult = (int)result;
82658   return jresult;
82659 }
82660
82661
82662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82663   int jresult ;
82664   int result;
82665
82666   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82667   jresult = (int)result;
82668   return jresult;
82669 }
82670
82671
82672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82673   int jresult ;
82674   int result;
82675
82676   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82677   jresult = (int)result;
82678   return jresult;
82679 }
82680
82681
82682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82683   int jresult ;
82684   int result;
82685
82686   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82687   jresult = (int)result;
82688   return jresult;
82689 }
82690
82691
82692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82693   int jresult ;
82694   int result;
82695
82696   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82697   jresult = (int)result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82703   int jresult ;
82704   int result;
82705
82706   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82707   jresult = (int)result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82713   int jresult ;
82714   int result;
82715
82716   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82717   jresult = (int)result;
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82723   int jresult ;
82724   int result;
82725
82726   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82727   jresult = (int)result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82733   int jresult ;
82734   int result;
82735
82736   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82737   jresult = (int)result;
82738   return jresult;
82739 }
82740
82741
82742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82743   int jresult ;
82744   int result;
82745
82746   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82747   jresult = (int)result;
82748   return jresult;
82749 }
82750
82751
82752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82753   void * jresult ;
82754   Dali::Toolkit::Popup::Property *result = 0 ;
82755
82756   {
82757     try {
82758       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82759     } catch (std::out_of_range& e) {
82760       {
82761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82762       };
82763     } catch (std::exception& e) {
82764       {
82765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82766       };
82767     } catch (...) {
82768       {
82769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82770       };
82771     }
82772   }
82773   jresult = (void *)result;
82774   return jresult;
82775 }
82776
82777
82778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82779   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82780
82781   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82782   {
82783     try {
82784       delete arg1;
82785     } catch (std::out_of_range& e) {
82786       {
82787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82788       };
82789     } catch (std::exception& e) {
82790       {
82791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82792       };
82793     } catch (...) {
82794       {
82795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82796       };
82797     }
82798   }
82799 }
82800
82801
82802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82803   void * jresult ;
82804   Dali::Toolkit::Popup *result = 0 ;
82805
82806   {
82807     try {
82808       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82809     } catch (std::out_of_range& e) {
82810       {
82811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82812       };
82813     } catch (std::exception& e) {
82814       {
82815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82816       };
82817     } catch (...) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82820       };
82821     }
82822   }
82823   jresult = (void *)result;
82824   return jresult;
82825 }
82826
82827
82828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82829   void * jresult ;
82830   Dali::Toolkit::Popup result;
82831
82832   {
82833     try {
82834       result = Dali::Toolkit::Popup::New();
82835     } catch (std::out_of_range& e) {
82836       {
82837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82838       };
82839     } catch (std::exception& e) {
82840       {
82841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82842       };
82843     } catch (...) {
82844       {
82845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82846       };
82847     }
82848   }
82849   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82855   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82856
82857   arg1 = (Dali::Toolkit::Popup *)jarg1;
82858   {
82859     try {
82860       delete arg1;
82861     } catch (std::out_of_range& e) {
82862       {
82863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82864       };
82865     } catch (std::exception& e) {
82866       {
82867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82868       };
82869     } catch (...) {
82870       {
82871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82872       };
82873     }
82874   }
82875 }
82876
82877
82878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82879   void * jresult ;
82880   Dali::Toolkit::Popup *arg1 = 0 ;
82881   Dali::Toolkit::Popup *result = 0 ;
82882
82883   arg1 = (Dali::Toolkit::Popup *)jarg1;
82884   if (!arg1) {
82885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82886     return 0;
82887   }
82888   {
82889     try {
82890       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82891     } catch (std::out_of_range& e) {
82892       {
82893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82894       };
82895     } catch (std::exception& e) {
82896       {
82897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82898       };
82899     } catch (...) {
82900       {
82901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82902       };
82903     }
82904   }
82905   jresult = (void *)result;
82906   return jresult;
82907 }
82908
82909
82910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82911   void * jresult ;
82912   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82913   Dali::Toolkit::Popup *arg2 = 0 ;
82914   Dali::Toolkit::Popup *result = 0 ;
82915
82916   arg1 = (Dali::Toolkit::Popup *)jarg1;
82917   arg2 = (Dali::Toolkit::Popup *)jarg2;
82918   if (!arg2) {
82919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82920     return 0;
82921   }
82922   {
82923     try {
82924       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82925     } catch (std::out_of_range& e) {
82926       {
82927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82928       };
82929     } catch (std::exception& e) {
82930       {
82931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82932       };
82933     } catch (...) {
82934       {
82935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82936       };
82937     }
82938   }
82939   jresult = (void *)result;
82940   return jresult;
82941 }
82942
82943
82944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82945   void * jresult ;
82946   Dali::BaseHandle arg1 ;
82947   Dali::BaseHandle *argp1 ;
82948   Dali::Toolkit::Popup result;
82949
82950   argp1 = (Dali::BaseHandle *)jarg1;
82951   if (!argp1) {
82952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82953     return 0;
82954   }
82955   arg1 = *argp1;
82956   {
82957     try {
82958       result = Dali::Toolkit::Popup::DownCast(arg1);
82959     } catch (std::out_of_range& e) {
82960       {
82961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82962       };
82963     } catch (std::exception& e) {
82964       {
82965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (...) {
82968       {
82969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82970       };
82971     }
82972   }
82973   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82979   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82980   Dali::Actor arg2 ;
82981   Dali::Actor *argp2 ;
82982
82983   arg1 = (Dali::Toolkit::Popup *)jarg1;
82984   argp2 = (Dali::Actor *)jarg2;
82985   if (!argp2) {
82986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82987     return ;
82988   }
82989   arg2 = *argp2;
82990   {
82991     try {
82992       (arg1)->SetTitle(arg2);
82993     } catch (std::out_of_range& e) {
82994       {
82995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82996       };
82997     } catch (std::exception& e) {
82998       {
82999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83000       };
83001     } catch (...) {
83002       {
83003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83004       };
83005     }
83006   }
83007 }
83008
83009
83010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83011   void * jresult ;
83012   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83013   Dali::Actor result;
83014
83015   arg1 = (Dali::Toolkit::Popup *)jarg1;
83016   {
83017     try {
83018       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83019     } catch (std::out_of_range& e) {
83020       {
83021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83022       };
83023     } catch (std::exception& e) {
83024       {
83025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83026       };
83027     } catch (...) {
83028       {
83029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83030       };
83031     }
83032   }
83033   jresult = new Dali::Actor((const Dali::Actor &)result);
83034   return jresult;
83035 }
83036
83037
83038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83039   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83040   Dali::Actor arg2 ;
83041   Dali::Actor *argp2 ;
83042
83043   arg1 = (Dali::Toolkit::Popup *)jarg1;
83044   argp2 = (Dali::Actor *)jarg2;
83045   if (!argp2) {
83046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83047     return ;
83048   }
83049   arg2 = *argp2;
83050   {
83051     try {
83052       (arg1)->SetContent(arg2);
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83060       };
83061     } catch (...) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83064       };
83065     }
83066   }
83067 }
83068
83069
83070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83071   void * jresult ;
83072   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83073   Dali::Actor result;
83074
83075   arg1 = (Dali::Toolkit::Popup *)jarg1;
83076   {
83077     try {
83078       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83079     } catch (std::out_of_range& e) {
83080       {
83081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83082       };
83083     } catch (std::exception& e) {
83084       {
83085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83086       };
83087     } catch (...) {
83088       {
83089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83090       };
83091     }
83092   }
83093   jresult = new Dali::Actor((const Dali::Actor &)result);
83094   return jresult;
83095 }
83096
83097
83098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83099   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83100   Dali::Actor arg2 ;
83101   Dali::Actor *argp2 ;
83102
83103   arg1 = (Dali::Toolkit::Popup *)jarg1;
83104   argp2 = (Dali::Actor *)jarg2;
83105   if (!argp2) {
83106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83107     return ;
83108   }
83109   arg2 = *argp2;
83110   {
83111     try {
83112       (arg1)->SetFooter(arg2);
83113     } catch (std::out_of_range& e) {
83114       {
83115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83116       };
83117     } catch (std::exception& e) {
83118       {
83119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83120       };
83121     } catch (...) {
83122       {
83123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83124       };
83125     }
83126   }
83127 }
83128
83129
83130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83131   void * jresult ;
83132   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83133   Dali::Actor result;
83134
83135   arg1 = (Dali::Toolkit::Popup *)jarg1;
83136   {
83137     try {
83138       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83139     } catch (std::out_of_range& e) {
83140       {
83141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83142       };
83143     } catch (std::exception& e) {
83144       {
83145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83146       };
83147     } catch (...) {
83148       {
83149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83150       };
83151     }
83152   }
83153   jresult = new Dali::Actor((const Dali::Actor &)result);
83154   return jresult;
83155 }
83156
83157
83158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83159   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83160   Dali::Toolkit::Popup::DisplayState arg2 ;
83161
83162   arg1 = (Dali::Toolkit::Popup *)jarg1;
83163   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83164   {
83165     try {
83166       (arg1)->SetDisplayState(arg2);
83167     } catch (std::out_of_range& e) {
83168       {
83169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83170       };
83171     } catch (std::exception& e) {
83172       {
83173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (...) {
83176       {
83177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83178       };
83179     }
83180   }
83181 }
83182
83183
83184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83185   int jresult ;
83186   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83187   Dali::Toolkit::Popup::DisplayState result;
83188
83189   arg1 = (Dali::Toolkit::Popup *)jarg1;
83190   {
83191     try {
83192       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83193     } catch (std::out_of_range& e) {
83194       {
83195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (std::exception& e) {
83198       {
83199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83200       };
83201     } catch (...) {
83202       {
83203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83204       };
83205     }
83206   }
83207   jresult = (int)result;
83208   return jresult;
83209 }
83210
83211
83212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83213   void * jresult ;
83214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83215   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83216
83217   arg1 = (Dali::Toolkit::Popup *)jarg1;
83218   {
83219     try {
83220       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83221     } catch (std::out_of_range& e) {
83222       {
83223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83224       };
83225     } catch (std::exception& e) {
83226       {
83227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (...) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83232       };
83233     }
83234   }
83235   jresult = (void *)result;
83236   return jresult;
83237 }
83238
83239
83240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83241   void * jresult ;
83242   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83243   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83244
83245   arg1 = (Dali::Toolkit::Popup *)jarg1;
83246   {
83247     try {
83248       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83249     } catch (std::out_of_range& e) {
83250       {
83251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (std::exception& e) {
83254       {
83255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83260       };
83261     }
83262   }
83263   jresult = (void *)result;
83264   return jresult;
83265 }
83266
83267
83268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83269   void * jresult ;
83270   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83271   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83272
83273   arg1 = (Dali::Toolkit::Popup *)jarg1;
83274   {
83275     try {
83276       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (...) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83288       };
83289     }
83290   }
83291   jresult = (void *)result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83297   void * jresult ;
83298   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83299   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83300
83301   arg1 = (Dali::Toolkit::Popup *)jarg1;
83302   {
83303     try {
83304       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83305     } catch (std::out_of_range& e) {
83306       {
83307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (std::exception& e) {
83310       {
83311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (...) {
83314       {
83315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83316       };
83317     }
83318   }
83319   jresult = (void *)result;
83320   return jresult;
83321 }
83322
83323
83324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83325   void * jresult ;
83326   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83327   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83328
83329   arg1 = (Dali::Toolkit::Popup *)jarg1;
83330   {
83331     try {
83332       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83333     } catch (std::out_of_range& e) {
83334       {
83335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83336       };
83337     } catch (std::exception& e) {
83338       {
83339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (...) {
83342       {
83343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83344       };
83345     }
83346   }
83347   jresult = (void *)result;
83348   return jresult;
83349 }
83350
83351
83352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83353   int jresult ;
83354   int result;
83355
83356   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83357   jresult = (int)result;
83358   return jresult;
83359 }
83360
83361
83362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83363   int jresult ;
83364   int result;
83365
83366   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83367   jresult = (int)result;
83368   return jresult;
83369 }
83370
83371
83372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83373   int jresult ;
83374   int result;
83375
83376   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83377   jresult = (int)result;
83378   return jresult;
83379 }
83380
83381
83382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83383   int jresult ;
83384   int result;
83385
83386   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83387   jresult = (int)result;
83388   return jresult;
83389 }
83390
83391
83392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83393   int jresult ;
83394   int result;
83395
83396   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83397   jresult = (int)result;
83398   return jresult;
83399 }
83400
83401
83402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83403   int jresult ;
83404   int result;
83405
83406   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83407   jresult = (int)result;
83408   return jresult;
83409 }
83410
83411
83412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83413   int jresult ;
83414   int result;
83415
83416   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83417   jresult = (int)result;
83418   return jresult;
83419 }
83420
83421
83422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83423   int jresult ;
83424   int result;
83425
83426   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83427   jresult = (int)result;
83428   return jresult;
83429 }
83430
83431
83432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83433   int jresult ;
83434   int result;
83435
83436   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83437   jresult = (int)result;
83438   return jresult;
83439 }
83440
83441
83442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83443   void * jresult ;
83444   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83445
83446   {
83447     try {
83448       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83449     } catch (std::out_of_range& e) {
83450       {
83451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (std::exception& e) {
83454       {
83455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83460       };
83461     }
83462   }
83463   jresult = (void *)result;
83464   return jresult;
83465 }
83466
83467
83468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83469   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83470
83471   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83472   {
83473     try {
83474       delete arg1;
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83482       };
83483     } catch (...) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83486       };
83487     }
83488   }
83489 }
83490
83491
83492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83493   void * jresult ;
83494   Dali::Toolkit::ProgressBar result;
83495
83496   {
83497     try {
83498       result = Dali::Toolkit::ProgressBar::New();
83499     } catch (std::out_of_range& e) {
83500       {
83501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83502       };
83503     } catch (std::exception& e) {
83504       {
83505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83506       };
83507     } catch (...) {
83508       {
83509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83510       };
83511     }
83512   }
83513   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83514   return jresult;
83515 }
83516
83517
83518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83519   void * jresult ;
83520   Dali::Toolkit::ProgressBar *result = 0 ;
83521
83522   {
83523     try {
83524       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83525     } catch (std::out_of_range& e) {
83526       {
83527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83528       };
83529     } catch (std::exception& e) {
83530       {
83531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (...) {
83534       {
83535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83536       };
83537     }
83538   }
83539   jresult = (void *)result;
83540   return jresult;
83541 }
83542
83543
83544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83545   void * jresult ;
83546   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83547   Dali::Toolkit::ProgressBar *result = 0 ;
83548
83549   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83550   if (!arg1) {
83551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83552     return 0;
83553   }
83554   {
83555     try {
83556       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83557     } catch (std::out_of_range& e) {
83558       {
83559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (std::exception& e) {
83562       {
83563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83564       };
83565     } catch (...) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83568       };
83569     }
83570   }
83571   jresult = (void *)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83577   void * jresult ;
83578   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83579   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83580   Dali::Toolkit::ProgressBar *result = 0 ;
83581
83582   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83583   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83584   if (!arg2) {
83585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83586     return 0;
83587   }
83588   {
83589     try {
83590       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83591     } catch (std::out_of_range& e) {
83592       {
83593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (std::exception& e) {
83596       {
83597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (...) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83602       };
83603     }
83604   }
83605   jresult = (void *)result;
83606   return jresult;
83607 }
83608
83609
83610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83611   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83612
83613   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83614   {
83615     try {
83616       delete arg1;
83617     } catch (std::out_of_range& e) {
83618       {
83619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83620       };
83621     } catch (std::exception& e) {
83622       {
83623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83624       };
83625     } catch (...) {
83626       {
83627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83628       };
83629     }
83630   }
83631 }
83632
83633
83634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83635   void * jresult ;
83636   Dali::BaseHandle arg1 ;
83637   Dali::BaseHandle *argp1 ;
83638   Dali::Toolkit::ProgressBar result;
83639
83640   argp1 = (Dali::BaseHandle *)jarg1;
83641   if (!argp1) {
83642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83643     return 0;
83644   }
83645   arg1 = *argp1;
83646   {
83647     try {
83648       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
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 (...) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83660       };
83661     }
83662   }
83663   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83664   return jresult;
83665 }
83666
83667
83668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83669   void * jresult ;
83670   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83671   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83672
83673   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83674   {
83675     try {
83676       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83677     } catch (std::out_of_range& e) {
83678       {
83679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83680       };
83681     } catch (std::exception& e) {
83682       {
83683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83684       };
83685     } catch (...) {
83686       {
83687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83688       };
83689     }
83690   }
83691   jresult = (void *)result;
83692   return jresult;
83693 }
83694
83695
83696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83697   void * jresult ;
83698   Dali::Toolkit::GaussianBlurView *result = 0 ;
83699
83700   {
83701     try {
83702       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83703     } catch (std::out_of_range& e) {
83704       {
83705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (std::exception& e) {
83708       {
83709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (...) {
83712       {
83713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83714       };
83715     }
83716   }
83717   jresult = (void *)result;
83718   return jresult;
83719 }
83720
83721
83722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83723   void * jresult ;
83724   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83725   Dali::Toolkit::GaussianBlurView *result = 0 ;
83726
83727   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83728   if (!arg1) {
83729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83730     return 0;
83731   }
83732   {
83733     try {
83734       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83735     } catch (std::out_of_range& e) {
83736       {
83737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83738       };
83739     } catch (std::exception& e) {
83740       {
83741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83742       };
83743     } catch (...) {
83744       {
83745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83746       };
83747     }
83748   }
83749   jresult = (void *)result;
83750   return jresult;
83751 }
83752
83753
83754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83755   void * jresult ;
83756   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83757   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83758   Dali::Toolkit::GaussianBlurView *result = 0 ;
83759
83760   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83761   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83762   if (!arg2) {
83763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83764     return 0;
83765   }
83766   {
83767     try {
83768       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83769     } catch (std::out_of_range& e) {
83770       {
83771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83772       };
83773     } catch (std::exception& e) {
83774       {
83775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83776       };
83777     } catch (...) {
83778       {
83779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83780       };
83781     }
83782   }
83783   jresult = (void *)result;
83784   return jresult;
83785 }
83786
83787
83788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83789   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83790
83791   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83792   {
83793     try {
83794       delete arg1;
83795     } catch (std::out_of_range& e) {
83796       {
83797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83798       };
83799     } catch (std::exception& e) {
83800       {
83801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83806       };
83807     }
83808   }
83809 }
83810
83811
83812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83813   void * jresult ;
83814   Dali::BaseHandle arg1 ;
83815   Dali::BaseHandle *argp1 ;
83816   Dali::Toolkit::GaussianBlurView result;
83817
83818   argp1 = (Dali::BaseHandle *)jarg1;
83819   if (!argp1) {
83820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83821     return 0;
83822   }
83823   arg1 = *argp1;
83824   {
83825     try {
83826       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83827     } catch (std::out_of_range& e) {
83828       {
83829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (std::exception& e) {
83832       {
83833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83834       };
83835     } catch (...) {
83836       {
83837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83838       };
83839     }
83840   }
83841   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83842   return jresult;
83843 }
83844
83845
83846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83847   void * jresult ;
83848   Dali::Toolkit::GaussianBlurView result;
83849
83850   {
83851     try {
83852       result = Dali::Toolkit::GaussianBlurView::New();
83853     } catch (std::out_of_range& e) {
83854       {
83855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83856       };
83857     } catch (std::exception& e) {
83858       {
83859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (...) {
83862       {
83863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83864       };
83865     }
83866   }
83867   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83868   return jresult;
83869 }
83870
83871
83872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83873   void * jresult ;
83874   unsigned int arg1 ;
83875   float arg2 ;
83876   Dali::Pixel::Format arg3 ;
83877   float arg4 ;
83878   float arg5 ;
83879   bool arg6 ;
83880   Dali::Toolkit::GaussianBlurView result;
83881
83882   arg1 = (unsigned int)jarg1;
83883   arg2 = (float)jarg2;
83884   arg3 = (Dali::Pixel::Format)jarg3;
83885   arg4 = (float)jarg4;
83886   arg5 = (float)jarg5;
83887   arg6 = jarg6 ? true : false;
83888   {
83889     try {
83890       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83891     } catch (std::out_of_range& e) {
83892       {
83893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83894       };
83895     } catch (std::exception& e) {
83896       {
83897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (...) {
83900       {
83901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83902       };
83903     }
83904   }
83905   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83906   return jresult;
83907 }
83908
83909
83910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83911   void * jresult ;
83912   unsigned int arg1 ;
83913   float arg2 ;
83914   Dali::Pixel::Format arg3 ;
83915   float arg4 ;
83916   float arg5 ;
83917   Dali::Toolkit::GaussianBlurView result;
83918
83919   arg1 = (unsigned int)jarg1;
83920   arg2 = (float)jarg2;
83921   arg3 = (Dali::Pixel::Format)jarg3;
83922   arg4 = (float)jarg4;
83923   arg5 = (float)jarg5;
83924   {
83925     try {
83926       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83927     } catch (std::out_of_range& e) {
83928       {
83929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83930       };
83931     } catch (std::exception& e) {
83932       {
83933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83934       };
83935     } catch (...) {
83936       {
83937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83938       };
83939     }
83940   }
83941   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83942   return jresult;
83943 }
83944
83945
83946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83947   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83948   Dali::Actor arg2 ;
83949   Dali::Actor *argp2 ;
83950
83951   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83952   argp2 = (Dali::Actor *)jarg2;
83953   if (!argp2) {
83954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83955     return ;
83956   }
83957   arg2 = *argp2;
83958   {
83959     try {
83960       (arg1)->Add(arg2);
83961     } catch (std::out_of_range& e) {
83962       {
83963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83964       };
83965     } catch (std::exception& e) {
83966       {
83967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83968       };
83969     } catch (...) {
83970       {
83971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83972       };
83973     }
83974   }
83975 }
83976
83977
83978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83979   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83980   Dali::Actor arg2 ;
83981   Dali::Actor *argp2 ;
83982
83983   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83984   argp2 = (Dali::Actor *)jarg2;
83985   if (!argp2) {
83986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83987     return ;
83988   }
83989   arg2 = *argp2;
83990   {
83991     try {
83992       (arg1)->Remove(arg2);
83993     } catch (std::out_of_range& e) {
83994       {
83995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83996       };
83997     } catch (std::exception& e) {
83998       {
83999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84000       };
84001     } catch (...) {
84002       {
84003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84004       };
84005     }
84006   }
84007 }
84008
84009
84010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84011   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84012
84013   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84014   {
84015     try {
84016       (arg1)->Activate();
84017     } catch (std::out_of_range& e) {
84018       {
84019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84020       };
84021     } catch (std::exception& e) {
84022       {
84023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84024       };
84025     } catch (...) {
84026       {
84027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84028       };
84029     }
84030   }
84031 }
84032
84033
84034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84035   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84036
84037   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84038   {
84039     try {
84040       (arg1)->ActivateOnce();
84041     } catch (std::out_of_range& e) {
84042       {
84043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84044       };
84045     } catch (std::exception& e) {
84046       {
84047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84048       };
84049     } catch (...) {
84050       {
84051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84052       };
84053     }
84054   }
84055 }
84056
84057
84058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84059   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84060
84061   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84062   {
84063     try {
84064       (arg1)->Deactivate();
84065     } catch (std::out_of_range& e) {
84066       {
84067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84068       };
84069     } catch (std::exception& e) {
84070       {
84071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84072       };
84073     } catch (...) {
84074       {
84075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84076       };
84077     }
84078   }
84079 }
84080
84081
84082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84083   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84084   Dali::Image arg2 ;
84085   Dali::FrameBufferImage arg3 ;
84086   Dali::Image *argp2 ;
84087   Dali::FrameBufferImage *argp3 ;
84088
84089   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84090   argp2 = (Dali::Image *)jarg2;
84091   if (!argp2) {
84092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84093     return ;
84094   }
84095   arg2 = *argp2;
84096   argp3 = (Dali::FrameBufferImage *)jarg3;
84097   if (!argp3) {
84098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84099     return ;
84100   }
84101   arg3 = *argp3;
84102   {
84103     try {
84104       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84105     } catch (std::out_of_range& e) {
84106       {
84107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84108       };
84109     } catch (std::exception& e) {
84110       {
84111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84112       };
84113     } catch (...) {
84114       {
84115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84116       };
84117     }
84118   }
84119 }
84120
84121
84122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84123   int jresult ;
84124   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84125   Dali::Property::Index result;
84126
84127   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84128   {
84129     try {
84130       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84138       };
84139     } catch (...) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84142       };
84143     }
84144   }
84145   jresult = result;
84146   return jresult;
84147 }
84148
84149
84150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84151   void * jresult ;
84152   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84153   Dali::FrameBufferImage result;
84154
84155   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84156   {
84157     try {
84158       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (...) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84170       };
84171     }
84172   }
84173   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84174   return jresult;
84175 }
84176
84177
84178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84179   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84180   Dali::Vector4 *arg2 = 0 ;
84181
84182   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84183   arg2 = (Dali::Vector4 *)jarg2;
84184   if (!arg2) {
84185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84186     return ;
84187   }
84188   {
84189     try {
84190       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84191     } catch (std::out_of_range& e) {
84192       {
84193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84194       };
84195     } catch (std::exception& e) {
84196       {
84197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84198       };
84199     } catch (...) {
84200       {
84201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84202       };
84203     }
84204   }
84205 }
84206
84207
84208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84209   void * jresult ;
84210   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84211   Dali::Vector4 result;
84212
84213   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84214   {
84215     try {
84216       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84228       };
84229     }
84230   }
84231   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84232   return jresult;
84233 }
84234
84235
84236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84237   void * jresult ;
84238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84239   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84240
84241   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84242   {
84243     try {
84244       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84245     } catch (std::out_of_range& e) {
84246       {
84247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (std::exception& e) {
84250       {
84251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84252       };
84253     } catch (...) {
84254       {
84255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84256       };
84257     }
84258   }
84259   jresult = (void *)result;
84260   return jresult;
84261 }
84262
84263
84264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84265   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84266
84267   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84268   {
84269     try {
84270       delete arg1;
84271     } catch (std::out_of_range& e) {
84272       {
84273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84274       };
84275     } catch (std::exception& e) {
84276       {
84277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84278       };
84279     } catch (...) {
84280       {
84281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84282       };
84283     }
84284   }
84285 }
84286
84287
84288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84289   unsigned int jresult ;
84290   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84291   unsigned int result;
84292
84293   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84294   {
84295     try {
84296       result = (unsigned int)(arg1)->GetNumberOfPages();
84297     } catch (std::out_of_range& e) {
84298       {
84299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84300       };
84301     } catch (std::exception& e) {
84302       {
84303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84304       };
84305     } catch (...) {
84306       {
84307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84308       };
84309     }
84310   }
84311   jresult = result;
84312   return jresult;
84313 }
84314
84315
84316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84317   void * jresult ;
84318   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84319   unsigned int arg2 ;
84320   Dali::Texture result;
84321
84322   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84323   arg2 = (unsigned int)jarg2;
84324   {
84325     try {
84326       result = (arg1)->NewPage(arg2);
84327     } catch (std::out_of_range& e) {
84328       {
84329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (std::exception& e) {
84332       {
84333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84334       };
84335     } catch (...) {
84336       {
84337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84338       };
84339     }
84340   }
84341   jresult = new Dali::Texture((const Dali::Texture &)result);
84342   return jresult;
84343 }
84344
84345
84346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84347   int jresult ;
84348   int result;
84349
84350   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84351   jresult = (int)result;
84352   return jresult;
84353 }
84354
84355
84356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84357   int jresult ;
84358   int result;
84359
84360   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84361   jresult = (int)result;
84362   return jresult;
84363 }
84364
84365
84366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84367   int jresult ;
84368   int result;
84369
84370   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84371   jresult = (int)result;
84372   return jresult;
84373 }
84374
84375
84376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84377   void * jresult ;
84378   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84379
84380   {
84381     try {
84382       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84383     } catch (std::out_of_range& e) {
84384       {
84385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84386       };
84387     } catch (std::exception& e) {
84388       {
84389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84390       };
84391     } catch (...) {
84392       {
84393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84394       };
84395     }
84396   }
84397   jresult = (void *)result;
84398   return jresult;
84399 }
84400
84401
84402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84403   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84404
84405   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84406   {
84407     try {
84408       delete arg1;
84409     } catch (std::out_of_range& e) {
84410       {
84411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84412       };
84413     } catch (std::exception& e) {
84414       {
84415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84416       };
84417     } catch (...) {
84418       {
84419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84420       };
84421     }
84422   }
84423 }
84424
84425
84426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84427   void * jresult ;
84428   Dali::Toolkit::PageTurnView *result = 0 ;
84429
84430   {
84431     try {
84432       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84433     } catch (std::out_of_range& e) {
84434       {
84435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84436       };
84437     } catch (std::exception& e) {
84438       {
84439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84440       };
84441     } catch (...) {
84442       {
84443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84444       };
84445     }
84446   }
84447   jresult = (void *)result;
84448   return jresult;
84449 }
84450
84451
84452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84453   void * jresult ;
84454   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84455   Dali::Toolkit::PageTurnView *result = 0 ;
84456
84457   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84458   if (!arg1) {
84459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84460     return 0;
84461   }
84462   {
84463     try {
84464       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84465     } catch (std::out_of_range& e) {
84466       {
84467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84468       };
84469     } catch (std::exception& e) {
84470       {
84471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (...) {
84474       {
84475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84476       };
84477     }
84478   }
84479   jresult = (void *)result;
84480   return jresult;
84481 }
84482
84483
84484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84485   void * jresult ;
84486   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84487   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84488   Dali::Toolkit::PageTurnView *result = 0 ;
84489
84490   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84491   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84492   if (!arg2) {
84493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84494     return 0;
84495   }
84496   {
84497     try {
84498       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84499     } catch (std::out_of_range& e) {
84500       {
84501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (std::exception& e) {
84504       {
84505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (...) {
84508       {
84509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84510       };
84511     }
84512   }
84513   jresult = (void *)result;
84514   return jresult;
84515 }
84516
84517
84518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84519   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84520
84521   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84522   {
84523     try {
84524       delete arg1;
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 (...) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84536       };
84537     }
84538   }
84539 }
84540
84541
84542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84543   void * jresult ;
84544   Dali::BaseHandle arg1 ;
84545   Dali::BaseHandle *argp1 ;
84546   Dali::Toolkit::PageTurnView result;
84547
84548   argp1 = (Dali::BaseHandle *)jarg1;
84549   if (!argp1) {
84550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84551     return 0;
84552   }
84553   arg1 = *argp1;
84554   {
84555     try {
84556       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84557     } catch (std::out_of_range& e) {
84558       {
84559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84560       };
84561     } catch (std::exception& e) {
84562       {
84563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84564       };
84565     } catch (...) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84568       };
84569     }
84570   }
84571   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84572   return jresult;
84573 }
84574
84575
84576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84577   void * jresult ;
84578   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84579   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84580
84581   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84582   {
84583     try {
84584       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84585     } catch (std::out_of_range& e) {
84586       {
84587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84588       };
84589     } catch (std::exception& e) {
84590       {
84591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84592       };
84593     } catch (...) {
84594       {
84595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84596       };
84597     }
84598   }
84599   jresult = (void *)result;
84600   return jresult;
84601 }
84602
84603
84604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84605   void * jresult ;
84606   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84607   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84608
84609   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84610   {
84611     try {
84612       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84613     } catch (std::out_of_range& e) {
84614       {
84615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84616       };
84617     } catch (std::exception& e) {
84618       {
84619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84620       };
84621     } catch (...) {
84622       {
84623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84624       };
84625     }
84626   }
84627   jresult = (void *)result;
84628   return jresult;
84629 }
84630
84631
84632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84633   void * jresult ;
84634   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84635   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84636
84637   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84638   {
84639     try {
84640       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84641     } catch (std::out_of_range& e) {
84642       {
84643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (std::exception& e) {
84646       {
84647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655   jresult = (void *)result;
84656   return jresult;
84657 }
84658
84659
84660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84661   void * jresult ;
84662   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84663   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84664
84665   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84666   {
84667     try {
84668       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84669     } catch (std::out_of_range& e) {
84670       {
84671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (std::exception& e) {
84674       {
84675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (...) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84680       };
84681     }
84682   }
84683   jresult = (void *)result;
84684   return jresult;
84685 }
84686
84687
84688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84689   void * jresult ;
84690   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84691
84692   {
84693     try {
84694       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84695     } catch (std::out_of_range& e) {
84696       {
84697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (std::exception& e) {
84700       {
84701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (...) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84706       };
84707     }
84708   }
84709   jresult = (void *)result;
84710   return jresult;
84711 }
84712
84713
84714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84715   void * jresult ;
84716   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84717   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84718
84719   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84720   if (!arg1) {
84721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84722     return 0;
84723   }
84724   {
84725     try {
84726       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84727     } catch (std::out_of_range& e) {
84728       {
84729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84730       };
84731     } catch (std::exception& e) {
84732       {
84733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84734       };
84735     } catch (...) {
84736       {
84737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84738       };
84739     }
84740   }
84741   jresult = (void *)result;
84742   return jresult;
84743 }
84744
84745
84746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84747   void * jresult ;
84748   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84749   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84750   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84751
84752   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84753   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84754   if (!arg2) {
84755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84756     return 0;
84757   }
84758   {
84759     try {
84760       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84761     } catch (std::out_of_range& e) {
84762       {
84763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84764       };
84765     } catch (std::exception& e) {
84766       {
84767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84768       };
84769     } catch (...) {
84770       {
84771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84772       };
84773     }
84774   }
84775   jresult = (void *)result;
84776   return jresult;
84777 }
84778
84779
84780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84781   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84782
84783   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84784   {
84785     try {
84786       delete arg1;
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84794       };
84795     } catch (...) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84798       };
84799     }
84800   }
84801 }
84802
84803
84804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84805   void * jresult ;
84806   Dali::Toolkit::PageFactory *arg1 = 0 ;
84807   Dali::Vector2 *arg2 = 0 ;
84808   Dali::Toolkit::PageTurnLandscapeView result;
84809
84810   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84811   if (!arg1) {
84812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84813     return 0;
84814   }
84815   arg2 = (Dali::Vector2 *)jarg2;
84816   if (!arg2) {
84817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84818     return 0;
84819   }
84820   {
84821     try {
84822       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84823     } catch (std::out_of_range& e) {
84824       {
84825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84826       };
84827     } catch (std::exception& e) {
84828       {
84829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84830       };
84831     } catch (...) {
84832       {
84833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84834       };
84835     }
84836   }
84837   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84838   return jresult;
84839 }
84840
84841
84842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84843   void * jresult ;
84844   Dali::BaseHandle arg1 ;
84845   Dali::BaseHandle *argp1 ;
84846   Dali::Toolkit::PageTurnLandscapeView result;
84847
84848   argp1 = (Dali::BaseHandle *)jarg1;
84849   if (!argp1) {
84850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84851     return 0;
84852   }
84853   arg1 = *argp1;
84854   {
84855     try {
84856       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
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 (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84877   void * jresult ;
84878   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84879
84880   {
84881     try {
84882       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84883     } catch (std::out_of_range& e) {
84884       {
84885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (std::exception& e) {
84888       {
84889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897   jresult = (void *)result;
84898   return jresult;
84899 }
84900
84901
84902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84903   void * jresult ;
84904   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84905   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84906
84907   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84908   if (!arg1) {
84909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84910     return 0;
84911   }
84912   {
84913     try {
84914       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84915     } catch (std::out_of_range& e) {
84916       {
84917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84918       };
84919     } catch (std::exception& e) {
84920       {
84921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (...) {
84924       {
84925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84926       };
84927     }
84928   }
84929   jresult = (void *)result;
84930   return jresult;
84931 }
84932
84933
84934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84935   void * jresult ;
84936   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84937   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84938   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84939
84940   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84941   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84942   if (!arg2) {
84943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84944     return 0;
84945   }
84946   {
84947     try {
84948       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84949     } catch (std::out_of_range& e) {
84950       {
84951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84952       };
84953     } catch (std::exception& e) {
84954       {
84955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84956       };
84957     } catch (...) {
84958       {
84959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84960       };
84961     }
84962   }
84963   jresult = (void *)result;
84964   return jresult;
84965 }
84966
84967
84968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84969   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84970
84971   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84972   {
84973     try {
84974       delete arg1;
84975     } catch (std::out_of_range& e) {
84976       {
84977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84978       };
84979     } catch (std::exception& e) {
84980       {
84981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84982       };
84983     } catch (...) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84986       };
84987     }
84988   }
84989 }
84990
84991
84992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84993   void * jresult ;
84994   Dali::Toolkit::PageFactory *arg1 = 0 ;
84995   Dali::Vector2 *arg2 = 0 ;
84996   Dali::Toolkit::PageTurnPortraitView result;
84997
84998   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84999   if (!arg1) {
85000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85001     return 0;
85002   }
85003   arg2 = (Dali::Vector2 *)jarg2;
85004   if (!arg2) {
85005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85006     return 0;
85007   }
85008   {
85009     try {
85010       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85011     } catch (std::out_of_range& e) {
85012       {
85013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85014       };
85015     } catch (std::exception& e) {
85016       {
85017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (...) {
85020       {
85021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85022       };
85023     }
85024   }
85025   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85026   return jresult;
85027 }
85028
85029
85030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85031   void * jresult ;
85032   Dali::BaseHandle arg1 ;
85033   Dali::BaseHandle *argp1 ;
85034   Dali::Toolkit::PageTurnPortraitView result;
85035
85036   argp1 = (Dali::BaseHandle *)jarg1;
85037   if (!argp1) {
85038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85039     return 0;
85040   }
85041   arg1 = *argp1;
85042   {
85043     try {
85044       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85045     } catch (std::out_of_range& e) {
85046       {
85047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85048       };
85049     } catch (std::exception& e) {
85050       {
85051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85052       };
85053     } catch (...) {
85054       {
85055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85056       };
85057     }
85058   }
85059   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85060   return jresult;
85061 }
85062
85063
85064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85065   int jresult ;
85066   int result;
85067
85068   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85069   jresult = (int)result;
85070   return jresult;
85071 }
85072
85073
85074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85075   int jresult ;
85076   int result;
85077
85078   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85079   jresult = (int)result;
85080   return jresult;
85081 }
85082
85083
85084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85085   int jresult ;
85086   int result;
85087
85088   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85089   jresult = (int)result;
85090   return jresult;
85091 }
85092
85093
85094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85095   void * jresult ;
85096   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85097
85098   {
85099     try {
85100       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85101     } catch (std::out_of_range& e) {
85102       {
85103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85104       };
85105     } catch (std::exception& e) {
85106       {
85107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85108       };
85109     } catch (...) {
85110       {
85111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85112       };
85113     }
85114   }
85115   jresult = (void *)result;
85116   return jresult;
85117 }
85118
85119
85120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85121   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85122
85123   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85124   {
85125     try {
85126       delete arg1;
85127     } catch (std::out_of_range& e) {
85128       {
85129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85130       };
85131     } catch (std::exception& e) {
85132       {
85133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85138       };
85139     }
85140   }
85141 }
85142
85143
85144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85145   void * jresult ;
85146   Dali::Toolkit::ToggleButton *result = 0 ;
85147
85148   {
85149     try {
85150       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85151     } catch (std::out_of_range& e) {
85152       {
85153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85154       };
85155     } catch (std::exception& e) {
85156       {
85157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (...) {
85160       {
85161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85162       };
85163     }
85164   }
85165   jresult = (void *)result;
85166   return jresult;
85167 }
85168
85169
85170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85171   void * jresult ;
85172   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85173   Dali::Toolkit::ToggleButton *result = 0 ;
85174
85175   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85176   if (!arg1) {
85177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85178     return 0;
85179   }
85180   {
85181     try {
85182       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85183     } catch (std::out_of_range& e) {
85184       {
85185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85186       };
85187     } catch (std::exception& e) {
85188       {
85189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85190       };
85191     } catch (...) {
85192       {
85193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85194       };
85195     }
85196   }
85197   jresult = (void *)result;
85198   return jresult;
85199 }
85200
85201
85202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85203   void * jresult ;
85204   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85205   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85206   Dali::Toolkit::ToggleButton *result = 0 ;
85207
85208   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85209   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85210   if (!arg2) {
85211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85212     return 0;
85213   }
85214   {
85215     try {
85216       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85217     } catch (std::out_of_range& e) {
85218       {
85219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85220       };
85221     } catch (std::exception& e) {
85222       {
85223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85224       };
85225     } catch (...) {
85226       {
85227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85228       };
85229     }
85230   }
85231   jresult = (void *)result;
85232   return jresult;
85233 }
85234
85235
85236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85237   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85238
85239   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85240   {
85241     try {
85242       delete arg1;
85243     } catch (std::out_of_range& e) {
85244       {
85245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85246       };
85247     } catch (std::exception& e) {
85248       {
85249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85250       };
85251     } catch (...) {
85252       {
85253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85254       };
85255     }
85256   }
85257 }
85258
85259
85260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85261   void * jresult ;
85262   Dali::Toolkit::ToggleButton result;
85263
85264   {
85265     try {
85266       result = Dali::Toolkit::ToggleButton::New();
85267     } catch (std::out_of_range& e) {
85268       {
85269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85270       };
85271     } catch (std::exception& e) {
85272       {
85273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85274       };
85275     } catch (...) {
85276       {
85277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85278       };
85279     }
85280   }
85281   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85282   return jresult;
85283 }
85284
85285
85286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85287   void * jresult ;
85288   Dali::BaseHandle arg1 ;
85289   Dali::BaseHandle *argp1 ;
85290   Dali::Toolkit::ToggleButton result;
85291
85292   argp1 = (Dali::BaseHandle *)jarg1;
85293   if (!argp1) {
85294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85295     return 0;
85296   }
85297   arg1 = *argp1;
85298   {
85299     try {
85300       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85301     } catch (std::out_of_range& e) {
85302       {
85303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85304       };
85305     } catch (std::exception& e) {
85306       {
85307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85308       };
85309     } catch (...) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85312       };
85313     }
85314   }
85315   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85316   return jresult;
85317 }
85318
85319
85320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85321   void * jresult ;
85322   Dali::Toolkit::Visual::Base *result = 0 ;
85323
85324   {
85325     try {
85326       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (...) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85338       };
85339     }
85340   }
85341   jresult = (void *)result;
85342   return jresult;
85343 }
85344
85345
85346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85347   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85348
85349   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85350   {
85351     try {
85352       delete arg1;
85353     } catch (std::out_of_range& e) {
85354       {
85355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85356       };
85357     } catch (std::exception& e) {
85358       {
85359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85364       };
85365     }
85366   }
85367 }
85368
85369
85370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85371   void * jresult ;
85372   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85373   Dali::Toolkit::Visual::Base *result = 0 ;
85374
85375   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85376   if (!arg1) {
85377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85378     return 0;
85379   }
85380   {
85381     try {
85382       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85383     } catch (std::out_of_range& e) {
85384       {
85385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85386       };
85387     } catch (std::exception& e) {
85388       {
85389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (...) {
85392       {
85393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85394       };
85395     }
85396   }
85397   jresult = (void *)result;
85398   return jresult;
85399 }
85400
85401
85402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85403   void * jresult ;
85404   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85405   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85406   Dali::Toolkit::Visual::Base *result = 0 ;
85407
85408   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85409   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85410   if (!arg2) {
85411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85412     return 0;
85413   }
85414   {
85415     try {
85416       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85417     } catch (std::out_of_range& e) {
85418       {
85419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85420       };
85421     } catch (std::exception& e) {
85422       {
85423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (...) {
85426       {
85427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85428       };
85429     }
85430   }
85431   jresult = (void *)result;
85432   return jresult;
85433 }
85434
85435
85436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85437   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85438   std::string *arg2 = 0 ;
85439
85440   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85441   if (!jarg2) {
85442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85443     return ;
85444   }
85445   std::string arg2_str(jarg2);
85446   arg2 = &arg2_str;
85447   {
85448     try {
85449       (arg1)->SetName((std::string const &)*arg2);
85450     } catch (std::out_of_range& e) {
85451       {
85452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85453       };
85454     } catch (std::exception& e) {
85455       {
85456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85457       };
85458     } catch (...) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85461       };
85462     }
85463   }
85464
85465   //argout typemap for const std::string&
85466
85467 }
85468
85469
85470 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85471   char * jresult ;
85472   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85473   std::string *result = 0 ;
85474
85475   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85476   {
85477     try {
85478       result = (std::string *) &(arg1)->GetName();
85479     } catch (std::out_of_range& e) {
85480       {
85481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85482       };
85483     } catch (std::exception& e) {
85484       {
85485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85486       };
85487     } catch (...) {
85488       {
85489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85490       };
85491     }
85492   }
85493   jresult = SWIG_csharp_string_callback(result->c_str());
85494   return jresult;
85495 }
85496
85497
85498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85499   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85500   Dali::Property::Map *arg2 = 0 ;
85501   Dali::Size arg3 ;
85502   Dali::Size *argp3 ;
85503
85504   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85505   arg2 = (Dali::Property::Map *)jarg2;
85506   if (!arg2) {
85507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85508     return ;
85509   }
85510   argp3 = (Dali::Size *)jarg3;
85511   if (!argp3) {
85512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85513     return ;
85514   }
85515   arg3 = *argp3;
85516   {
85517     try {
85518       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85519     } catch (std::out_of_range& e) {
85520       {
85521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85522       };
85523     } catch (std::exception& e) {
85524       {
85525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85526       };
85527     } catch (...) {
85528       {
85529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85530       };
85531     }
85532   }
85533 }
85534
85535
85536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85537   float jresult ;
85538   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85539   float arg2 ;
85540   float result;
85541
85542   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85543   arg2 = (float)jarg2;
85544   {
85545     try {
85546       result = (float)(arg1)->GetHeightForWidth(arg2);
85547     } catch (std::out_of_range& e) {
85548       {
85549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (std::exception& e) {
85552       {
85553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (...) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85558       };
85559     }
85560   }
85561   jresult = result;
85562   return jresult;
85563 }
85564
85565
85566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85567   float jresult ;
85568   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85569   float arg2 ;
85570   float result;
85571
85572   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85573   arg2 = (float)jarg2;
85574   {
85575     try {
85576       result = (float)(arg1)->GetWidthForHeight(arg2);
85577     } catch (std::out_of_range& e) {
85578       {
85579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85580       };
85581     } catch (std::exception& e) {
85582       {
85583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85584       };
85585     } catch (...) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85588       };
85589     }
85590   }
85591   jresult = result;
85592   return jresult;
85593 }
85594
85595
85596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85597   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85598   Dali::Vector2 *arg2 = 0 ;
85599
85600   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85601   arg2 = (Dali::Vector2 *)jarg2;
85602   if (!arg2) {
85603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85604     return ;
85605   }
85606   {
85607     try {
85608       (arg1)->GetNaturalSize(*arg2);
85609     } catch (std::out_of_range& e) {
85610       {
85611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85612       };
85613     } catch (std::exception& e) {
85614       {
85615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85616       };
85617     } catch (...) {
85618       {
85619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85620       };
85621     }
85622   }
85623 }
85624
85625
85626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85627   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85628   float arg2 ;
85629
85630   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85631   arg2 = (float)jarg2;
85632   {
85633     try {
85634       (arg1)->SetDepthIndex(arg2);
85635     } catch (std::out_of_range& e) {
85636       {
85637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85638       };
85639     } catch (std::exception& e) {
85640       {
85641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85646       };
85647     }
85648   }
85649 }
85650
85651
85652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85653   float jresult ;
85654   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85655   float result;
85656
85657   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85658   {
85659     try {
85660       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85661     } catch (std::out_of_range& e) {
85662       {
85663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85664       };
85665     } catch (std::exception& e) {
85666       {
85667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85668       };
85669     } catch (...) {
85670       {
85671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85672       };
85673     }
85674   }
85675   jresult = result;
85676   return jresult;
85677 }
85678
85679
85680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85681   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85682   Dali::Property::Map *arg2 = 0 ;
85683
85684   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85685   arg2 = (Dali::Property::Map *)jarg2;
85686   if (!arg2) {
85687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85688     return ;
85689   }
85690   {
85691     try {
85692       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85693     } catch (std::out_of_range& e) {
85694       {
85695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85696       };
85697     } catch (std::exception& e) {
85698       {
85699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85700       };
85701     } catch (...) {
85702       {
85703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85704       };
85705     }
85706   }
85707 }
85708
85709
85710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85711   void * jresult ;
85712   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85713   Dali::Toolkit::Visual::Base *result = 0 ;
85714
85715   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85716   {
85717     try {
85718       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85719     } catch (std::out_of_range& e) {
85720       {
85721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85722       };
85723     } catch (std::exception& e) {
85724       {
85725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85726       };
85727     } catch (...) {
85728       {
85729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85730       };
85731     }
85732   }
85733   jresult = (void *)result;
85734   return jresult;
85735 }
85736
85737
85738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85739   void * jresult ;
85740   Dali::Toolkit::VisualFactory result;
85741
85742   {
85743     try {
85744       result = Dali::Toolkit::VisualFactory::Get();
85745     } catch (std::out_of_range& e) {
85746       {
85747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85748       };
85749     } catch (std::exception& e) {
85750       {
85751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (...) {
85754       {
85755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85756       };
85757     }
85758   }
85759   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85760   return jresult;
85761 }
85762
85763
85764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85765   void * jresult ;
85766   Dali::Toolkit::VisualFactory *result = 0 ;
85767
85768   {
85769     try {
85770       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85771     } catch (std::out_of_range& e) {
85772       {
85773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85774       };
85775     } catch (std::exception& e) {
85776       {
85777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85778       };
85779     } catch (...) {
85780       {
85781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85782       };
85783     }
85784   }
85785   jresult = (void *)result;
85786   return jresult;
85787 }
85788
85789
85790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85791   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85792
85793   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85794   {
85795     try {
85796       delete arg1;
85797     } catch (std::out_of_range& e) {
85798       {
85799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85800       };
85801     } catch (std::exception& e) {
85802       {
85803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85804       };
85805     } catch (...) {
85806       {
85807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85808       };
85809     }
85810   }
85811 }
85812
85813
85814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85815   void * jresult ;
85816   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85817   Dali::Toolkit::VisualFactory *result = 0 ;
85818
85819   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85820   if (!arg1) {
85821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85822     return 0;
85823   }
85824   {
85825     try {
85826       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85827     } catch (std::out_of_range& e) {
85828       {
85829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85830       };
85831     } catch (std::exception& e) {
85832       {
85833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85834       };
85835     } catch (...) {
85836       {
85837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85838       };
85839     }
85840   }
85841   jresult = (void *)result;
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85847   void * jresult ;
85848   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85849   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85850   Dali::Toolkit::VisualFactory *result = 0 ;
85851
85852   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85853   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85854   if (!arg2) {
85855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85856     return 0;
85857   }
85858   {
85859     try {
85860       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
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 (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875   jresult = (void *)result;
85876   return jresult;
85877 }
85878
85879
85880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85881   void * jresult ;
85882   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85883   Dali::Property::Map *arg2 = 0 ;
85884   Dali::Toolkit::Visual::Base result;
85885
85886   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85887   arg2 = (Dali::Property::Map *)jarg2;
85888   if (!arg2) {
85889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85890     return 0;
85891   }
85892   {
85893     try {
85894       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85895     } catch (std::out_of_range& e) {
85896       {
85897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (std::exception& e) {
85900       {
85901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85902       };
85903     } catch (...) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85906       };
85907     }
85908   }
85909   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85915   void * jresult ;
85916   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85917   Dali::Image *arg2 = 0 ;
85918   Dali::Toolkit::Visual::Base result;
85919
85920   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85921   arg2 = (Dali::Image *)jarg2;
85922   if (!arg2) {
85923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85924     return 0;
85925   }
85926   {
85927     try {
85928       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85929     } catch (std::out_of_range& e) {
85930       {
85931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85932       };
85933     } catch (std::exception& e) {
85934       {
85935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85936       };
85937     } catch (...) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85940       };
85941     }
85942   }
85943   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85944   return jresult;
85945 }
85946
85947
85948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85949   void * jresult ;
85950   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85951   std::string *arg2 = 0 ;
85952   Dali::ImageDimensions arg3 ;
85953   Dali::ImageDimensions *argp3 ;
85954   Dali::Toolkit::Visual::Base result;
85955
85956   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85957   if (!jarg2) {
85958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85959     return 0;
85960   }
85961   std::string arg2_str(jarg2);
85962   arg2 = &arg2_str;
85963   argp3 = (Dali::ImageDimensions *)jarg3;
85964   if (!argp3) {
85965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85966     return 0;
85967   }
85968   arg3 = *argp3;
85969   {
85970     try {
85971       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85972     } catch (std::out_of_range& e) {
85973       {
85974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85975       };
85976     } catch (std::exception& e) {
85977       {
85978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (...) {
85981       {
85982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85983       };
85984     }
85985   }
85986   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85987
85988   //argout typemap for const std::string&
85989
85990   return jresult;
85991 }
85992
85993
85994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85995   void * jresult ;
85996   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85997
85998   {
85999     try {
86000       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86001     } catch (std::out_of_range& e) {
86002       {
86003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (std::exception& e) {
86006       {
86007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86008       };
86009     } catch (...) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86012       };
86013     }
86014   }
86015   jresult = (void *)result;
86016   return jresult;
86017 }
86018
86019
86020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86021   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86022
86023   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86024   {
86025     try {
86026       delete arg1;
86027     } catch (std::out_of_range& e) {
86028       {
86029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86030       };
86031     } catch (std::exception& e) {
86032       {
86033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86034       };
86035     } catch (...) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86038       };
86039     }
86040   }
86041 }
86042
86043
86044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86045   void * jresult ;
86046   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86047   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86048
86049   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86050   if (!arg1) {
86051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86052     return 0;
86053   }
86054   {
86055     try {
86056       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86057     } catch (std::out_of_range& e) {
86058       {
86059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (std::exception& e) {
86062       {
86063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86064       };
86065     } catch (...) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86068       };
86069     }
86070   }
86071   jresult = (void *)result;
86072   return jresult;
86073 }
86074
86075
86076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86077   void * jresult ;
86078   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86079   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86080   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86081
86082   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86083   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86084   if (!arg2) {
86085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86086     return 0;
86087   }
86088   {
86089     try {
86090       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86091     } catch (std::out_of_range& e) {
86092       {
86093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (std::exception& e) {
86096       {
86097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86098       };
86099     } catch (...) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86102       };
86103     }
86104   }
86105   jresult = (void *)result;
86106   return jresult;
86107 }
86108
86109
86110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86111   void * jresult ;
86112   Dali::Toolkit::AsyncImageLoader result;
86113
86114   {
86115     try {
86116       result = Dali::Toolkit::AsyncImageLoader::New();
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (...) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86128       };
86129     }
86130   }
86131   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86137   void * jresult ;
86138   Dali::BaseHandle arg1 ;
86139   Dali::BaseHandle *argp1 ;
86140   Dali::Toolkit::AsyncImageLoader result;
86141
86142   argp1 = (Dali::BaseHandle *)jarg1;
86143   if (!argp1) {
86144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86145     return 0;
86146   }
86147   arg1 = *argp1;
86148   {
86149     try {
86150       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86151     } catch (std::out_of_range& e) {
86152       {
86153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86154       };
86155     } catch (std::exception& e) {
86156       {
86157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86158       };
86159     } catch (...) {
86160       {
86161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86162       };
86163     }
86164   }
86165   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86166   return jresult;
86167 }
86168
86169
86170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86171   unsigned int jresult ;
86172   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86173   std::string *arg2 = 0 ;
86174   uint32_t result;
86175
86176   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86177   if (!jarg2) {
86178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86179     return 0;
86180   }
86181   std::string arg2_str(jarg2);
86182   arg2 = &arg2_str;
86183   {
86184     try {
86185       result = (arg1)->Load((std::string const &)*arg2);
86186     } catch (std::out_of_range& e) {
86187       {
86188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86189       };
86190     } catch (std::exception& e) {
86191       {
86192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86193       };
86194     } catch (...) {
86195       {
86196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86197       };
86198     }
86199   }
86200   jresult = result;
86201
86202   //argout typemap for const std::string&
86203
86204   return jresult;
86205 }
86206
86207
86208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86209   unsigned int jresult ;
86210   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86211   std::string *arg2 = 0 ;
86212   Dali::ImageDimensions arg3 ;
86213   Dali::ImageDimensions *argp3 ;
86214   uint32_t result;
86215
86216   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86217   if (!jarg2) {
86218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86219     return 0;
86220   }
86221   std::string arg2_str(jarg2);
86222   arg2 = &arg2_str;
86223   argp3 = (Dali::ImageDimensions *)jarg3;
86224   if (!argp3) {
86225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86226     return 0;
86227   }
86228   arg3 = *argp3;
86229   {
86230     try {
86231       result = (arg1)->Load((std::string const &)*arg2,arg3);
86232     } catch (std::out_of_range& e) {
86233       {
86234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86235       };
86236     } catch (std::exception& e) {
86237       {
86238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86239       };
86240     } catch (...) {
86241       {
86242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86243       };
86244     }
86245   }
86246   jresult = result;
86247
86248   //argout typemap for const std::string&
86249
86250   return jresult;
86251 }
86252
86253
86254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86255   unsigned int jresult ;
86256   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86257   std::string *arg2 = 0 ;
86258   Dali::ImageDimensions arg3 ;
86259   Dali::FittingMode::Type arg4 ;
86260   Dali::SamplingMode::Type arg5 ;
86261   bool arg6 ;
86262   Dali::ImageDimensions *argp3 ;
86263   uint32_t result;
86264
86265   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86266   if (!jarg2) {
86267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86268     return 0;
86269   }
86270   std::string arg2_str(jarg2);
86271   arg2 = &arg2_str;
86272   argp3 = (Dali::ImageDimensions *)jarg3;
86273   if (!argp3) {
86274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86275     return 0;
86276   }
86277   arg3 = *argp3;
86278   arg4 = (Dali::FittingMode::Type)jarg4;
86279   arg5 = (Dali::SamplingMode::Type)jarg5;
86280   arg6 = jarg6 ? true : false;
86281   {
86282     try {
86283       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86284     } catch (std::out_of_range& e) {
86285       {
86286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86287       };
86288     } catch (std::exception& e) {
86289       {
86290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86291       };
86292     } catch (...) {
86293       {
86294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86295       };
86296     }
86297   }
86298   jresult = result;
86299
86300   //argout typemap for const std::string&
86301
86302   return jresult;
86303 }
86304
86305
86306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86307   unsigned int jresult ;
86308   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86309   uint32_t arg2 ;
86310   bool result;
86311
86312   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86313   arg2 = (uint32_t)jarg2;
86314   {
86315     try {
86316       result = (bool)(arg1)->Cancel(arg2);
86317     } catch (std::out_of_range& e) {
86318       {
86319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (std::exception& e) {
86322       {
86323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86324       };
86325     } catch (...) {
86326       {
86327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86328       };
86329     }
86330   }
86331   jresult = result;
86332   return jresult;
86333 }
86334
86335
86336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86337   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86338
86339   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86340   {
86341     try {
86342       (arg1)->CancelAll();
86343     } catch (std::out_of_range& e) {
86344       {
86345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86346       };
86347     } catch (std::exception& e) {
86348       {
86349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86350       };
86351     } catch (...) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86354       };
86355     }
86356   }
86357 }
86358
86359
86360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86361   void * jresult ;
86362   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86363   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86364
86365   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86366   {
86367     try {
86368       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86369     } catch (std::out_of_range& e) {
86370       {
86371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86372       };
86373     } catch (std::exception& e) {
86374       {
86375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86376       };
86377     } catch (...) {
86378       {
86379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86380       };
86381     }
86382   }
86383   jresult = (void *)result;
86384   return jresult;
86385 }
86386
86387
86388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86389   void * jresult ;
86390   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86391   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86392
86393   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86394   {
86395     try {
86396       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86397     } catch (std::out_of_range& e) {
86398       {
86399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86400       };
86401     } catch (std::exception& e) {
86402       {
86403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86404       };
86405     } catch (...) {
86406       {
86407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86408       };
86409     }
86410   }
86411   jresult = (void *)result;
86412   return jresult;
86413 }
86414
86415
86416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86417   void * jresult ;
86418   std::string *arg1 = 0 ;
86419   Dali::PixelData result;
86420
86421   if (!jarg1) {
86422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86423     return 0;
86424   }
86425   std::string arg1_str(jarg1);
86426   arg1 = &arg1_str;
86427   {
86428     try {
86429       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86430     } catch (std::out_of_range& e) {
86431       {
86432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86433       };
86434     } catch (std::exception& e) {
86435       {
86436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86437       };
86438     } catch (...) {
86439       {
86440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86441       };
86442     }
86443   }
86444   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86445
86446   //argout typemap for const std::string&
86447
86448   return jresult;
86449 }
86450
86451
86452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86453   void * jresult ;
86454   std::string *arg1 = 0 ;
86455   Dali::ImageDimensions arg2 ;
86456   Dali::ImageDimensions *argp2 ;
86457   Dali::PixelData result;
86458
86459   if (!jarg1) {
86460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86461     return 0;
86462   }
86463   std::string arg1_str(jarg1);
86464   arg1 = &arg1_str;
86465   argp2 = (Dali::ImageDimensions *)jarg2;
86466   if (!argp2) {
86467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86468     return 0;
86469   }
86470   arg2 = *argp2;
86471   {
86472     try {
86473       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86474     } catch (std::out_of_range& e) {
86475       {
86476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86477       };
86478     } catch (std::exception& e) {
86479       {
86480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86485       };
86486     }
86487   }
86488   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86489
86490   //argout typemap for const std::string&
86491
86492   return jresult;
86493 }
86494
86495
86496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86497   void * jresult ;
86498   std::string *arg1 = 0 ;
86499   Dali::ImageDimensions arg2 ;
86500   Dali::FittingMode::Type arg3 ;
86501   Dali::SamplingMode::Type arg4 ;
86502   bool arg5 ;
86503   Dali::ImageDimensions *argp2 ;
86504   Dali::PixelData result;
86505
86506   if (!jarg1) {
86507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86508     return 0;
86509   }
86510   std::string arg1_str(jarg1);
86511   arg1 = &arg1_str;
86512   argp2 = (Dali::ImageDimensions *)jarg2;
86513   if (!argp2) {
86514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86515     return 0;
86516   }
86517   arg2 = *argp2;
86518   arg3 = (Dali::FittingMode::Type)jarg3;
86519   arg4 = (Dali::SamplingMode::Type)jarg4;
86520   arg5 = jarg5 ? true : false;
86521   {
86522     try {
86523       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86524     } catch (std::out_of_range& e) {
86525       {
86526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (std::exception& e) {
86529       {
86530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (...) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86535       };
86536     }
86537   }
86538   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86539
86540   //argout typemap for const std::string&
86541
86542   return jresult;
86543 }
86544
86545
86546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86547   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86548
86549   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86550   {
86551     try {
86552       delete arg1;
86553     } catch (std::out_of_range& e) {
86554       {
86555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86556       };
86557     } catch (std::exception& e) {
86558       {
86559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86560       };
86561     } catch (...) {
86562       {
86563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86564       };
86565     }
86566   }
86567 }
86568
86569
86570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86571   void * jresult ;
86572   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86573   Dali::Actor arg2 ;
86574   Dali::Actor arg3 ;
86575   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86576   Dali::Actor *argp2 ;
86577   Dali::Actor *argp3 ;
86578   Dali::Actor result;
86579
86580   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86581   argp2 = (Dali::Actor *)jarg2;
86582   if (!argp2) {
86583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86584     return 0;
86585   }
86586   arg2 = *argp2;
86587   argp3 = (Dali::Actor *)jarg3;
86588   if (!argp3) {
86589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86590     return 0;
86591   }
86592   arg3 = *argp3;
86593   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86594   {
86595     try {
86596       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86597     } catch (std::out_of_range& e) {
86598       {
86599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86600       };
86601     } catch (std::exception& e) {
86602       {
86603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86604       };
86605     } catch (...) {
86606       {
86607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86608       };
86609     }
86610   }
86611   jresult = new Dali::Actor((const Dali::Actor &)result);
86612   return jresult;
86613 }
86614
86615
86616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86617   void * jresult ;
86618   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86619
86620   {
86621     try {
86622       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86623     } catch (std::out_of_range& e) {
86624       {
86625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86626       };
86627     } catch (std::exception& e) {
86628       {
86629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86630       };
86631     } catch (...) {
86632       {
86633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86634       };
86635     }
86636   }
86637   jresult = (void *)result;
86638   return jresult;
86639 }
86640
86641
86642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86643   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86644   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86645   if (director) {
86646     director->swig_connect_director(callback0);
86647   }
86648 }
86649
86650
86651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86652   KeyboardFocusManager arg1 ;
86653   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86654   KeyboardFocusManager *argp1 ;
86655
86656   argp1 = (KeyboardFocusManager *)jarg1;
86657   if (!argp1) {
86658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86659     return ;
86660   }
86661   arg1 = *argp1;
86662   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86663   if (!arg2) {
86664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86665     return ;
86666   }
86667   {
86668     try {
86669       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86670     } catch (std::out_of_range& e) {
86671       {
86672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86673       };
86674     } catch (std::exception& e) {
86675       {
86676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86677       };
86678     } catch (...) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86681       };
86682     }
86683   }
86684 }
86685
86686
86687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86688   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86689
86690   arg1 = (std::vector< unsigned int > *)jarg1;
86691   {
86692     try {
86693       (arg1)->clear();
86694     } catch (std::out_of_range& e) {
86695       {
86696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86697       };
86698     } catch (std::exception& e) {
86699       {
86700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86701       };
86702     } catch (...) {
86703       {
86704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86705       };
86706     }
86707   }
86708 }
86709
86710
86711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86712   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86713   unsigned int *arg2 = 0 ;
86714   unsigned int temp2 ;
86715
86716   arg1 = (std::vector< unsigned int > *)jarg1;
86717   temp2 = (unsigned int)jarg2;
86718   arg2 = &temp2;
86719   {
86720     try {
86721       (arg1)->push_back((unsigned int const &)*arg2);
86722     } catch (std::out_of_range& e) {
86723       {
86724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86725       };
86726     } catch (std::exception& e) {
86727       {
86728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86729       };
86730     } catch (...) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86733       };
86734     }
86735   }
86736 }
86737
86738
86739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86740   unsigned long jresult ;
86741   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86742   std::vector< unsigned int >::size_type result;
86743
86744   arg1 = (std::vector< unsigned int > *)jarg1;
86745   {
86746     try {
86747       result = ((std::vector< unsigned int > const *)arg1)->size();
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86759       };
86760     }
86761   }
86762   jresult = (unsigned long)result;
86763   return jresult;
86764 }
86765
86766
86767 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86768   unsigned long jresult ;
86769   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86770   std::vector< unsigned int >::size_type result;
86771
86772   arg1 = (std::vector< unsigned int > *)jarg1;
86773   {
86774     try {
86775       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86776     } catch (std::out_of_range& e) {
86777       {
86778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (std::exception& e) {
86781       {
86782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86783       };
86784     } catch (...) {
86785       {
86786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86787       };
86788     }
86789   }
86790   jresult = (unsigned long)result;
86791   return jresult;
86792 }
86793
86794
86795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86796   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86797   std::vector< unsigned int >::size_type arg2 ;
86798
86799   arg1 = (std::vector< unsigned int > *)jarg1;
86800   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86801   {
86802     try {
86803       (arg1)->reserve(arg2);
86804     } catch (std::out_of_range& e) {
86805       {
86806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86807       };
86808     } catch (std::exception& e) {
86809       {
86810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86811       };
86812     } catch (...) {
86813       {
86814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86815       };
86816     }
86817   }
86818 }
86819
86820
86821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86822   void * jresult ;
86823   std::vector< unsigned int > *result = 0 ;
86824
86825   {
86826     try {
86827       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86828     } catch (std::out_of_range& e) {
86829       {
86830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86831       };
86832     } catch (std::exception& e) {
86833       {
86834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86835       };
86836     } catch (...) {
86837       {
86838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86839       };
86840     }
86841   }
86842   jresult = (void *)result;
86843   return jresult;
86844 }
86845
86846
86847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86848   void * jresult ;
86849   std::vector< unsigned int > *arg1 = 0 ;
86850   std::vector< unsigned int > *result = 0 ;
86851
86852   arg1 = (std::vector< unsigned int > *)jarg1;
86853   if (!arg1) {
86854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86855     return 0;
86856   }
86857   {
86858     try {
86859       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86860     } catch (std::out_of_range& e) {
86861       {
86862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86863       };
86864     } catch (std::exception& e) {
86865       {
86866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86867       };
86868     } catch (...) {
86869       {
86870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86871       };
86872     }
86873   }
86874   jresult = (void *)result;
86875   return jresult;
86876 }
86877
86878
86879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86880   void * jresult ;
86881   int arg1 ;
86882   std::vector< unsigned int > *result = 0 ;
86883
86884   arg1 = (int)jarg1;
86885   {
86886     try {
86887       try {
86888         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86889       }
86890       catch(std::out_of_range &_e) {
86891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86892         return 0;
86893       }
86894
86895     } catch (std::out_of_range& e) {
86896       {
86897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86898       };
86899     } catch (std::exception& e) {
86900       {
86901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86902       };
86903     } catch (...) {
86904       {
86905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86906       };
86907     }
86908   }
86909   jresult = (void *)result;
86910   return jresult;
86911 }
86912
86913
86914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86915   unsigned int jresult ;
86916   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86917   int arg2 ;
86918   unsigned int result;
86919
86920   arg1 = (std::vector< unsigned int > *)jarg1;
86921   arg2 = (int)jarg2;
86922   {
86923     try {
86924       try {
86925         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86926       }
86927       catch(std::out_of_range &_e) {
86928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86929         return 0;
86930       }
86931
86932     } catch (std::out_of_range& e) {
86933       {
86934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86935       };
86936     } catch (std::exception& e) {
86937       {
86938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86939       };
86940     } catch (...) {
86941       {
86942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86943       };
86944     }
86945   }
86946   jresult = result;
86947   return jresult;
86948 }
86949
86950
86951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86952   unsigned int jresult ;
86953   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86954   int arg2 ;
86955   unsigned int *result = 0 ;
86956
86957   arg1 = (std::vector< unsigned int > *)jarg1;
86958   arg2 = (int)jarg2;
86959   {
86960     try {
86961       try {
86962         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86963       }
86964       catch(std::out_of_range &_e) {
86965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86966         return 0;
86967       }
86968
86969     } catch (std::out_of_range& e) {
86970       {
86971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (std::exception& e) {
86974       {
86975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86976       };
86977     } catch (...) {
86978       {
86979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86980       };
86981     }
86982   }
86983   jresult = *result;
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86989   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86990   int arg2 ;
86991   unsigned int *arg3 = 0 ;
86992   unsigned int temp3 ;
86993
86994   arg1 = (std::vector< unsigned int > *)jarg1;
86995   arg2 = (int)jarg2;
86996   temp3 = (unsigned int)jarg3;
86997   arg3 = &temp3;
86998   {
86999     try {
87000       try {
87001         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87002       }
87003       catch(std::out_of_range &_e) {
87004         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87005         return ;
87006       }
87007
87008     } catch (std::out_of_range& e) {
87009       {
87010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87011       };
87012     } catch (std::exception& e) {
87013       {
87014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87015       };
87016     } catch (...) {
87017       {
87018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87019       };
87020     }
87021   }
87022 }
87023
87024
87025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87026   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87027   std::vector< unsigned int > *arg2 = 0 ;
87028
87029   arg1 = (std::vector< unsigned int > *)jarg1;
87030   arg2 = (std::vector< unsigned int > *)jarg2;
87031   if (!arg2) {
87032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87033     return ;
87034   }
87035   {
87036     try {
87037       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87038     } catch (std::out_of_range& e) {
87039       {
87040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (std::exception& e) {
87043       {
87044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87045       };
87046     } catch (...) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87049       };
87050     }
87051   }
87052 }
87053
87054
87055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87056   void * jresult ;
87057   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87058   int arg2 ;
87059   int arg3 ;
87060   std::vector< unsigned int > *result = 0 ;
87061
87062   arg1 = (std::vector< unsigned int > *)jarg1;
87063   arg2 = (int)jarg2;
87064   arg3 = (int)jarg3;
87065   {
87066     try {
87067       try {
87068         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87069       }
87070       catch(std::out_of_range &_e) {
87071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87072         return 0;
87073       }
87074       catch(std::invalid_argument &_e) {
87075         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87076         return 0;
87077       }
87078
87079     } catch (std::out_of_range& e) {
87080       {
87081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87082       };
87083     } catch (std::exception& e) {
87084       {
87085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87086       };
87087     } catch (...) {
87088       {
87089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87090       };
87091     }
87092   }
87093   jresult = (void *)result;
87094   return jresult;
87095 }
87096
87097
87098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87099   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87100   int arg2 ;
87101   unsigned int *arg3 = 0 ;
87102   unsigned int temp3 ;
87103
87104   arg1 = (std::vector< unsigned int > *)jarg1;
87105   arg2 = (int)jarg2;
87106   temp3 = (unsigned int)jarg3;
87107   arg3 = &temp3;
87108   {
87109     try {
87110       try {
87111         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87112       }
87113       catch(std::out_of_range &_e) {
87114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87115         return ;
87116       }
87117
87118     } catch (std::out_of_range& e) {
87119       {
87120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87121       };
87122     } catch (std::exception& e) {
87123       {
87124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87125       };
87126     } catch (...) {
87127       {
87128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87129       };
87130     }
87131   }
87132 }
87133
87134
87135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87137   int arg2 ;
87138   std::vector< unsigned int > *arg3 = 0 ;
87139
87140   arg1 = (std::vector< unsigned int > *)jarg1;
87141   arg2 = (int)jarg2;
87142   arg3 = (std::vector< unsigned int > *)jarg3;
87143   if (!arg3) {
87144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87145     return ;
87146   }
87147   {
87148     try {
87149       try {
87150         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87151       }
87152       catch(std::out_of_range &_e) {
87153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87154         return ;
87155       }
87156
87157     } catch (std::out_of_range& e) {
87158       {
87159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87160       };
87161     } catch (std::exception& e) {
87162       {
87163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87164       };
87165     } catch (...) {
87166       {
87167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87168       };
87169     }
87170   }
87171 }
87172
87173
87174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87175   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87176   int arg2 ;
87177
87178   arg1 = (std::vector< unsigned int > *)jarg1;
87179   arg2 = (int)jarg2;
87180   {
87181     try {
87182       try {
87183         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87184       }
87185       catch(std::out_of_range &_e) {
87186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87187         return ;
87188       }
87189
87190     } catch (std::out_of_range& e) {
87191       {
87192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87193       };
87194     } catch (std::exception& e) {
87195       {
87196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87197       };
87198     } catch (...) {
87199       {
87200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87201       };
87202     }
87203   }
87204 }
87205
87206
87207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87208   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87209   int arg2 ;
87210   int arg3 ;
87211
87212   arg1 = (std::vector< unsigned int > *)jarg1;
87213   arg2 = (int)jarg2;
87214   arg3 = (int)jarg3;
87215   {
87216     try {
87217       try {
87218         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87219       }
87220       catch(std::out_of_range &_e) {
87221         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87222         return ;
87223       }
87224       catch(std::invalid_argument &_e) {
87225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87226         return ;
87227       }
87228
87229     } catch (std::out_of_range& e) {
87230       {
87231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87232       };
87233     } catch (std::exception& e) {
87234       {
87235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87236       };
87237     } catch (...) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87240       };
87241     }
87242   }
87243 }
87244
87245
87246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87247   void * jresult ;
87248   unsigned int *arg1 = 0 ;
87249   int arg2 ;
87250   unsigned int temp1 ;
87251   std::vector< unsigned int > *result = 0 ;
87252
87253   temp1 = (unsigned int)jarg1;
87254   arg1 = &temp1;
87255   arg2 = (int)jarg2;
87256   {
87257     try {
87258       try {
87259         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87260       }
87261       catch(std::out_of_range &_e) {
87262         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87263         return 0;
87264       }
87265
87266     } catch (std::out_of_range& e) {
87267       {
87268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87269       };
87270     } catch (std::exception& e) {
87271       {
87272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87273       };
87274     } catch (...) {
87275       {
87276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87277       };
87278     }
87279   }
87280   jresult = (void *)result;
87281   return jresult;
87282 }
87283
87284
87285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87287
87288   arg1 = (std::vector< unsigned int > *)jarg1;
87289   {
87290     try {
87291       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(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 (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87303       };
87304     }
87305   }
87306 }
87307
87308
87309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87310   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87311   int arg2 ;
87312   int arg3 ;
87313
87314   arg1 = (std::vector< unsigned int > *)jarg1;
87315   arg2 = (int)jarg2;
87316   arg3 = (int)jarg3;
87317   {
87318     try {
87319       try {
87320         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87321       }
87322       catch(std::out_of_range &_e) {
87323         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87324         return ;
87325       }
87326       catch(std::invalid_argument &_e) {
87327         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87328         return ;
87329       }
87330
87331     } catch (std::out_of_range& e) {
87332       {
87333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87334       };
87335     } catch (std::exception& e) {
87336       {
87337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87338       };
87339     } catch (...) {
87340       {
87341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87342       };
87343     }
87344   }
87345 }
87346
87347
87348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87349   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87350   int arg2 ;
87351   std::vector< unsigned int > *arg3 = 0 ;
87352
87353   arg1 = (std::vector< unsigned int > *)jarg1;
87354   arg2 = (int)jarg2;
87355   arg3 = (std::vector< unsigned int > *)jarg3;
87356   if (!arg3) {
87357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87358     return ;
87359   }
87360   {
87361     try {
87362       try {
87363         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87364       }
87365       catch(std::out_of_range &_e) {
87366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87367         return ;
87368       }
87369
87370     } catch (std::out_of_range& e) {
87371       {
87372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87373       };
87374     } catch (std::exception& e) {
87375       {
87376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87377       };
87378     } catch (...) {
87379       {
87380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87381       };
87382     }
87383   }
87384 }
87385
87386
87387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87388   unsigned int jresult ;
87389   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87390   unsigned int *arg2 = 0 ;
87391   unsigned int temp2 ;
87392   bool result;
87393
87394   arg1 = (std::vector< unsigned int > *)jarg1;
87395   temp2 = (unsigned int)jarg2;
87396   arg2 = &temp2;
87397   {
87398     try {
87399       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87400     } catch (std::out_of_range& e) {
87401       {
87402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87403       };
87404     } catch (std::exception& e) {
87405       {
87406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87407       };
87408     } catch (...) {
87409       {
87410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87411       };
87412     }
87413   }
87414   jresult = result;
87415   return jresult;
87416 }
87417
87418
87419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87420   int jresult ;
87421   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87422   unsigned int *arg2 = 0 ;
87423   unsigned int temp2 ;
87424   int result;
87425
87426   arg1 = (std::vector< unsigned int > *)jarg1;
87427   temp2 = (unsigned int)jarg2;
87428   arg2 = &temp2;
87429   {
87430     try {
87431       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87432     } catch (std::out_of_range& e) {
87433       {
87434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87435       };
87436     } catch (std::exception& e) {
87437       {
87438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87439       };
87440     } catch (...) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87443       };
87444     }
87445   }
87446   jresult = result;
87447   return jresult;
87448 }
87449
87450
87451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87452   int jresult ;
87453   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87454   unsigned int *arg2 = 0 ;
87455   unsigned int temp2 ;
87456   int result;
87457
87458   arg1 = (std::vector< unsigned int > *)jarg1;
87459   temp2 = (unsigned int)jarg2;
87460   arg2 = &temp2;
87461   {
87462     try {
87463       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87464     } catch (std::out_of_range& e) {
87465       {
87466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87467       };
87468     } catch (std::exception& e) {
87469       {
87470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87471       };
87472     } catch (...) {
87473       {
87474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87475       };
87476     }
87477   }
87478   jresult = result;
87479   return jresult;
87480 }
87481
87482
87483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87484   unsigned int jresult ;
87485   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87486   unsigned int *arg2 = 0 ;
87487   unsigned int temp2 ;
87488   bool result;
87489
87490   arg1 = (std::vector< unsigned int > *)jarg1;
87491   temp2 = (unsigned int)jarg2;
87492   arg2 = &temp2;
87493   {
87494     try {
87495       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87496     } catch (std::out_of_range& e) {
87497       {
87498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87499       };
87500     } catch (std::exception& e) {
87501       {
87502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87503       };
87504     } catch (...) {
87505       {
87506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87507       };
87508     }
87509   }
87510   jresult = result;
87511   return jresult;
87512 }
87513
87514
87515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87516   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87517
87518   arg1 = (std::vector< unsigned int > *)jarg1;
87519   {
87520     try {
87521       delete arg1;
87522     } catch (std::out_of_range& e) {
87523       {
87524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87525       };
87526     } catch (std::exception& e) {
87527       {
87528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87529       };
87530     } catch (...) {
87531       {
87532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87533       };
87534     }
87535   }
87536 }
87537
87538
87539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87540   void * jresult ;
87541   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87542
87543   {
87544     try {
87545       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87546     } catch (std::out_of_range& e) {
87547       {
87548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87549       };
87550     } catch (std::exception& e) {
87551       {
87552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87553       };
87554     } catch (...) {
87555       {
87556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87557       };
87558     }
87559   }
87560   jresult = (void *)result;
87561   return jresult;
87562 }
87563
87564
87565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87566   void * jresult ;
87567   unsigned int arg1 ;
87568   Dali::Actor arg2 ;
87569   Dali::Actor *argp2 ;
87570   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87571
87572   arg1 = (unsigned int)jarg1;
87573   argp2 = (Dali::Actor *)jarg2;
87574   if (!argp2) {
87575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87576     return 0;
87577   }
87578   arg2 = *argp2;
87579   {
87580     try {
87581       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87582     } catch (std::out_of_range& e) {
87583       {
87584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87585       };
87586     } catch (std::exception& e) {
87587       {
87588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87589       };
87590     } catch (...) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87593       };
87594     }
87595   }
87596   jresult = (void *)result;
87597   return jresult;
87598 }
87599
87600
87601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87602   void * jresult ;
87603   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87604   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87605
87606   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87607   if (!arg1) {
87608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87609     return 0;
87610   }
87611   {
87612     try {
87613       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87614     } catch (std::out_of_range& e) {
87615       {
87616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87617       };
87618     } catch (std::exception& e) {
87619       {
87620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87621       };
87622     } catch (...) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87625       };
87626     }
87627   }
87628   jresult = (void *)result;
87629   return jresult;
87630 }
87631
87632
87633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87634   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87635   unsigned int arg2 ;
87636
87637   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87638   arg2 = (unsigned int)jarg2;
87639   if (arg1) (arg1)->first = arg2;
87640 }
87641
87642
87643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87644   unsigned int jresult ;
87645   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87646   unsigned int result;
87647
87648   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87649   result = (unsigned int) ((arg1)->first);
87650   jresult = result;
87651   return jresult;
87652 }
87653
87654
87655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87656   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87657   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87658
87659   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87660   arg2 = (Dali::Actor *)jarg2;
87661   if (arg1) (arg1)->second = *arg2;
87662 }
87663
87664
87665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87666   void * jresult ;
87667   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87668   Dali::Actor *result = 0 ;
87669
87670   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87671   result = (Dali::Actor *)& ((arg1)->second);
87672   jresult = (void *)result;
87673   return jresult;
87674 }
87675
87676
87677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87678   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87679
87680   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87681   {
87682     try {
87683       delete arg1;
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (...) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87695       };
87696     }
87697   }
87698 }
87699
87700
87701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87702   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87703
87704   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87705   {
87706     try {
87707       (arg1)->clear();
87708     } catch (std::out_of_range& e) {
87709       {
87710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87711       };
87712     } catch (std::exception& e) {
87713       {
87714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87715       };
87716     } catch (...) {
87717       {
87718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87719       };
87720     }
87721   }
87722 }
87723
87724
87725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87726   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87727   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87728
87729   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87730   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87731   if (!arg2) {
87732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87733     return ;
87734   }
87735   {
87736     try {
87737       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87738     } catch (std::out_of_range& e) {
87739       {
87740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87741       };
87742     } catch (std::exception& e) {
87743       {
87744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87745       };
87746     } catch (...) {
87747       {
87748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87749       };
87750     }
87751   }
87752 }
87753
87754
87755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87756   unsigned long jresult ;
87757   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87758   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87759
87760   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87761   {
87762     try {
87763       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87764     } catch (std::out_of_range& e) {
87765       {
87766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87767       };
87768     } catch (std::exception& e) {
87769       {
87770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87771       };
87772     } catch (...) {
87773       {
87774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87775       };
87776     }
87777   }
87778   jresult = (unsigned long)result;
87779   return jresult;
87780 }
87781
87782
87783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87784   unsigned long jresult ;
87785   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87786   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87787
87788   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87789   {
87790     try {
87791       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87792     } catch (std::out_of_range& e) {
87793       {
87794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87795       };
87796     } catch (std::exception& e) {
87797       {
87798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87799       };
87800     } catch (...) {
87801       {
87802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87803       };
87804     }
87805   }
87806   jresult = (unsigned long)result;
87807   return jresult;
87808 }
87809
87810
87811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87812   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87813   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87814
87815   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87816   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87817   {
87818     try {
87819       (arg1)->reserve(arg2);
87820     } catch (std::out_of_range& e) {
87821       {
87822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87823       };
87824     } catch (std::exception& e) {
87825       {
87826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87827       };
87828     } catch (...) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87831       };
87832     }
87833   }
87834 }
87835
87836
87837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87838   void * jresult ;
87839   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87840
87841   {
87842     try {
87843       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87844     } catch (std::out_of_range& e) {
87845       {
87846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87847       };
87848     } catch (std::exception& e) {
87849       {
87850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (...) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87855       };
87856     }
87857   }
87858   jresult = (void *)result;
87859   return jresult;
87860 }
87861
87862
87863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87864   void * jresult ;
87865   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87866   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87867
87868   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87869   if (!arg1) {
87870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87871     return 0;
87872   }
87873   {
87874     try {
87875       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);
87876     } catch (std::out_of_range& e) {
87877       {
87878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87879       };
87880     } catch (std::exception& e) {
87881       {
87882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87883       };
87884     } catch (...) {
87885       {
87886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87887       };
87888     }
87889   }
87890   jresult = (void *)result;
87891   return jresult;
87892 }
87893
87894
87895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87896   void * jresult ;
87897   int arg1 ;
87898   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87899
87900   arg1 = (int)jarg1;
87901   {
87902     try {
87903       try {
87904         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);
87905       }
87906       catch(std::out_of_range &_e) {
87907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87908         return 0;
87909       }
87910
87911     } catch (std::out_of_range& e) {
87912       {
87913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87914       };
87915     } catch (std::exception& e) {
87916       {
87917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87918       };
87919     } catch (...) {
87920       {
87921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87922       };
87923     }
87924   }
87925   jresult = (void *)result;
87926   return jresult;
87927 }
87928
87929
87930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87931   void * jresult ;
87932   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87933   int arg2 ;
87934   std::pair< unsigned int,Dali::Actor > result;
87935
87936   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87937   arg2 = (int)jarg2;
87938   {
87939     try {
87940       try {
87941         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87942       }
87943       catch(std::out_of_range &_e) {
87944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87945         return 0;
87946       }
87947
87948     } catch (std::out_of_range& e) {
87949       {
87950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87951       };
87952     } catch (std::exception& e) {
87953       {
87954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87955       };
87956     } catch (...) {
87957       {
87958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87959       };
87960     }
87961   }
87962   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87963   return jresult;
87964 }
87965
87966
87967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87968   void * jresult ;
87969   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87970   int arg2 ;
87971   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87972
87973   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87974   arg2 = (int)jarg2;
87975   {
87976     try {
87977       try {
87978         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87979       }
87980       catch(std::out_of_range &_e) {
87981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87982         return 0;
87983       }
87984
87985     } catch (std::out_of_range& e) {
87986       {
87987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87988       };
87989     } catch (std::exception& e) {
87990       {
87991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87992       };
87993     } catch (...) {
87994       {
87995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87996       };
87997     }
87998   }
87999   jresult = (void *)result;
88000   return jresult;
88001 }
88002
88003
88004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88005   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88006   int arg2 ;
88007   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88008
88009   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88010   arg2 = (int)jarg2;
88011   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88012   if (!arg3) {
88013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88014     return ;
88015   }
88016   {
88017     try {
88018       try {
88019         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);
88020       }
88021       catch(std::out_of_range &_e) {
88022         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88023         return ;
88024       }
88025
88026     } catch (std::out_of_range& e) {
88027       {
88028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88029       };
88030     } catch (std::exception& e) {
88031       {
88032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88033       };
88034     } catch (...) {
88035       {
88036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88037       };
88038     }
88039   }
88040 }
88041
88042
88043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88044   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88045   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88046
88047   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88048   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88049   if (!arg2) {
88050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88051     return ;
88052   }
88053   {
88054     try {
88055       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);
88056     } catch (std::out_of_range& e) {
88057       {
88058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88059       };
88060     } catch (std::exception& e) {
88061       {
88062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88063       };
88064     } catch (...) {
88065       {
88066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88067       };
88068     }
88069   }
88070 }
88071
88072
88073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88074   void * jresult ;
88075   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88076   int arg2 ;
88077   int arg3 ;
88078   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88079
88080   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88081   arg2 = (int)jarg2;
88082   arg3 = (int)jarg3;
88083   {
88084     try {
88085       try {
88086         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);
88087       }
88088       catch(std::out_of_range &_e) {
88089         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88090         return 0;
88091       }
88092       catch(std::invalid_argument &_e) {
88093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88094         return 0;
88095       }
88096
88097     } catch (std::out_of_range& e) {
88098       {
88099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88100       };
88101     } catch (std::exception& e) {
88102       {
88103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88104       };
88105     } catch (...) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88108       };
88109     }
88110   }
88111   jresult = (void *)result;
88112   return jresult;
88113 }
88114
88115
88116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88117   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88118   int arg2 ;
88119   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88120
88121   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88122   arg2 = (int)jarg2;
88123   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88124   if (!arg3) {
88125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88126     return ;
88127   }
88128   {
88129     try {
88130       try {
88131         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);
88132       }
88133       catch(std::out_of_range &_e) {
88134         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88135         return ;
88136       }
88137
88138     } catch (std::out_of_range& e) {
88139       {
88140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88141       };
88142     } catch (std::exception& e) {
88143       {
88144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88145       };
88146     } catch (...) {
88147       {
88148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88149       };
88150     }
88151   }
88152 }
88153
88154
88155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88156   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88157   int arg2 ;
88158   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88159
88160   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88161   arg2 = (int)jarg2;
88162   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88163   if (!arg3) {
88164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88165     return ;
88166   }
88167   {
88168     try {
88169       try {
88170         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);
88171       }
88172       catch(std::out_of_range &_e) {
88173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88174         return ;
88175       }
88176
88177     } catch (std::out_of_range& e) {
88178       {
88179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88180       };
88181     } catch (std::exception& e) {
88182       {
88183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88184       };
88185     } catch (...) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88188       };
88189     }
88190   }
88191 }
88192
88193
88194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88195   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88196   int arg2 ;
88197
88198   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88199   arg2 = (int)jarg2;
88200   {
88201     try {
88202       try {
88203         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88204       }
88205       catch(std::out_of_range &_e) {
88206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88207         return ;
88208       }
88209
88210     } catch (std::out_of_range& e) {
88211       {
88212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88213       };
88214     } catch (std::exception& e) {
88215       {
88216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88217       };
88218     } catch (...) {
88219       {
88220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88221       };
88222     }
88223   }
88224 }
88225
88226
88227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88228   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88229   int arg2 ;
88230   int arg3 ;
88231
88232   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88233   arg2 = (int)jarg2;
88234   arg3 = (int)jarg3;
88235   {
88236     try {
88237       try {
88238         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88239       }
88240       catch(std::out_of_range &_e) {
88241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88242         return ;
88243       }
88244       catch(std::invalid_argument &_e) {
88245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88246         return ;
88247       }
88248
88249     } catch (std::out_of_range& e) {
88250       {
88251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88252       };
88253     } catch (std::exception& e) {
88254       {
88255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88256       };
88257     } catch (...) {
88258       {
88259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88260       };
88261     }
88262   }
88263 }
88264
88265
88266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88267   void * jresult ;
88268   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88269   int arg2 ;
88270   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88271
88272   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88273   if (!arg1) {
88274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88275     return 0;
88276   }
88277   arg2 = (int)jarg2;
88278   {
88279     try {
88280       try {
88281         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);
88282       }
88283       catch(std::out_of_range &_e) {
88284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88285         return 0;
88286       }
88287
88288     } catch (std::out_of_range& e) {
88289       {
88290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88291       };
88292     } catch (std::exception& e) {
88293       {
88294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88295       };
88296     } catch (...) {
88297       {
88298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88299       };
88300     }
88301   }
88302   jresult = (void *)result;
88303   return jresult;
88304 }
88305
88306
88307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88308   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88309
88310   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88311   {
88312     try {
88313       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88325       };
88326     }
88327   }
88328 }
88329
88330
88331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88332   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88333   int arg2 ;
88334   int arg3 ;
88335
88336   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88337   arg2 = (int)jarg2;
88338   arg3 = (int)jarg3;
88339   {
88340     try {
88341       try {
88342         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88343       }
88344       catch(std::out_of_range &_e) {
88345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88346         return ;
88347       }
88348       catch(std::invalid_argument &_e) {
88349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88350         return ;
88351       }
88352
88353     } catch (std::out_of_range& e) {
88354       {
88355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88356       };
88357     } catch (std::exception& e) {
88358       {
88359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88360       };
88361     } catch (...) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88364       };
88365     }
88366   }
88367 }
88368
88369
88370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88371   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88372   int arg2 ;
88373   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88374
88375   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88376   arg2 = (int)jarg2;
88377   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88378   if (!arg3) {
88379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88380     return ;
88381   }
88382   {
88383     try {
88384       try {
88385         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);
88386       }
88387       catch(std::out_of_range &_e) {
88388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88389         return ;
88390       }
88391
88392     } catch (std::out_of_range& e) {
88393       {
88394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88395       };
88396     } catch (std::exception& e) {
88397       {
88398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88399       };
88400     } catch (...) {
88401       {
88402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88403       };
88404     }
88405   }
88406 }
88407
88408
88409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88410   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88411
88412   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88413   {
88414     try {
88415       delete arg1;
88416     } catch (std::out_of_range& e) {
88417       {
88418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88419       };
88420     } catch (std::exception& e) {
88421       {
88422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88423       };
88424     } catch (...) {
88425       {
88426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88427       };
88428     }
88429   }
88430 }
88431
88432
88433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88434   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88435
88436   arg1 = (std::vector< Dali::Actor > *)jarg1;
88437   {
88438     try {
88439       (arg1)->clear();
88440     } catch (std::out_of_range& e) {
88441       {
88442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88443       };
88444     } catch (std::exception& e) {
88445       {
88446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88447       };
88448     } catch (...) {
88449       {
88450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88451       };
88452     }
88453   }
88454 }
88455
88456
88457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88458   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88459   Dali::Actor *arg2 = 0 ;
88460
88461   arg1 = (std::vector< Dali::Actor > *)jarg1;
88462   arg2 = (Dali::Actor *)jarg2;
88463   if (!arg2) {
88464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88465     return ;
88466   }
88467   {
88468     try {
88469       (arg1)->push_back((Dali::Actor const &)*arg2);
88470     } catch (std::out_of_range& e) {
88471       {
88472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88473       };
88474     } catch (std::exception& e) {
88475       {
88476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88477       };
88478     } catch (...) {
88479       {
88480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88481       };
88482     }
88483   }
88484 }
88485
88486
88487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88488   unsigned long jresult ;
88489   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88490   std::vector< Dali::Actor >::size_type result;
88491
88492   arg1 = (std::vector< Dali::Actor > *)jarg1;
88493   {
88494     try {
88495       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88496     } catch (std::out_of_range& e) {
88497       {
88498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88499       };
88500     } catch (std::exception& e) {
88501       {
88502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88503       };
88504     } catch (...) {
88505       {
88506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88507       };
88508     }
88509   }
88510   jresult = (unsigned long)result;
88511   return jresult;
88512 }
88513
88514
88515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88516   unsigned long jresult ;
88517   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88518   std::vector< Dali::Actor >::size_type result;
88519
88520   arg1 = (std::vector< Dali::Actor > *)jarg1;
88521   {
88522     try {
88523       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88524     } catch (std::out_of_range& e) {
88525       {
88526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (std::exception& e) {
88529       {
88530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (...) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88535       };
88536     }
88537   }
88538   jresult = (unsigned long)result;
88539   return jresult;
88540 }
88541
88542
88543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88544   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88545   std::vector< Dali::Actor >::size_type arg2 ;
88546
88547   arg1 = (std::vector< Dali::Actor > *)jarg1;
88548   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88549   {
88550     try {
88551       (arg1)->reserve(arg2);
88552     } catch (std::out_of_range& e) {
88553       {
88554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88555       };
88556     } catch (std::exception& e) {
88557       {
88558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88559       };
88560     } catch (...) {
88561       {
88562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88563       };
88564     }
88565   }
88566 }
88567
88568
88569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88570   void * jresult ;
88571   std::vector< Dali::Actor > *result = 0 ;
88572
88573   {
88574     try {
88575       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88576     } catch (std::out_of_range& e) {
88577       {
88578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88579       };
88580     } catch (std::exception& e) {
88581       {
88582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88583       };
88584     } catch (...) {
88585       {
88586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88587       };
88588     }
88589   }
88590   jresult = (void *)result;
88591   return jresult;
88592 }
88593
88594
88595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88596   void * jresult ;
88597   std::vector< Dali::Actor > *arg1 = 0 ;
88598   std::vector< Dali::Actor > *result = 0 ;
88599
88600   arg1 = (std::vector< Dali::Actor > *)jarg1;
88601   if (!arg1) {
88602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88603     return 0;
88604   }
88605   {
88606     try {
88607       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88608     } catch (std::out_of_range& e) {
88609       {
88610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88611       };
88612     } catch (std::exception& e) {
88613       {
88614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (...) {
88617       {
88618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88619       };
88620     }
88621   }
88622   jresult = (void *)result;
88623   return jresult;
88624 }
88625
88626
88627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88628   void * jresult ;
88629   int arg1 ;
88630   std::vector< Dali::Actor > *result = 0 ;
88631
88632   arg1 = (int)jarg1;
88633   {
88634     try {
88635       try {
88636         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88637       }
88638       catch(std::out_of_range &_e) {
88639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88640         return 0;
88641       }
88642
88643     } catch (std::out_of_range& e) {
88644       {
88645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88646       };
88647     } catch (std::exception& e) {
88648       {
88649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (...) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88654       };
88655     }
88656   }
88657   jresult = (void *)result;
88658   return jresult;
88659 }
88660
88661
88662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88663   void * jresult ;
88664   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88665   int arg2 ;
88666   Dali::Actor result;
88667
88668   arg1 = (std::vector< Dali::Actor > *)jarg1;
88669   arg2 = (int)jarg2;
88670   {
88671     try {
88672       try {
88673         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88674       }
88675       catch(std::out_of_range &_e) {
88676         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88677         return 0;
88678       }
88679
88680     } catch (std::out_of_range& e) {
88681       {
88682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88683       };
88684     } catch (std::exception& e) {
88685       {
88686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88687       };
88688     } catch (...) {
88689       {
88690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88691       };
88692     }
88693   }
88694   jresult = new Dali::Actor((const Dali::Actor &)result);
88695   return jresult;
88696 }
88697
88698
88699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88700   void * jresult ;
88701   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88702   int arg2 ;
88703   Dali::Actor *result = 0 ;
88704
88705   arg1 = (std::vector< Dali::Actor > *)jarg1;
88706   arg2 = (int)jarg2;
88707   {
88708     try {
88709       try {
88710         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88711       }
88712       catch(std::out_of_range &_e) {
88713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88714         return 0;
88715       }
88716
88717     } catch (std::out_of_range& e) {
88718       {
88719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88720       };
88721     } catch (std::exception& e) {
88722       {
88723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88724       };
88725     } catch (...) {
88726       {
88727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88728       };
88729     }
88730   }
88731   jresult = (void *)result;
88732   return jresult;
88733 }
88734
88735
88736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88737   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88738   int arg2 ;
88739   Dali::Actor *arg3 = 0 ;
88740
88741   arg1 = (std::vector< Dali::Actor > *)jarg1;
88742   arg2 = (int)jarg2;
88743   arg3 = (Dali::Actor *)jarg3;
88744   if (!arg3) {
88745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88746     return ;
88747   }
88748   {
88749     try {
88750       try {
88751         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88752       }
88753       catch(std::out_of_range &_e) {
88754         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88755         return ;
88756       }
88757
88758     } catch (std::out_of_range& e) {
88759       {
88760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88761       };
88762     } catch (std::exception& e) {
88763       {
88764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88765       };
88766     } catch (...) {
88767       {
88768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88769       };
88770     }
88771   }
88772 }
88773
88774
88775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88776   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88777   std::vector< Dali::Actor > *arg2 = 0 ;
88778
88779   arg1 = (std::vector< Dali::Actor > *)jarg1;
88780   arg2 = (std::vector< Dali::Actor > *)jarg2;
88781   if (!arg2) {
88782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88783     return ;
88784   }
88785   {
88786     try {
88787       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88788     } catch (std::out_of_range& e) {
88789       {
88790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88791       };
88792     } catch (std::exception& e) {
88793       {
88794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88795       };
88796     } catch (...) {
88797       {
88798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88799       };
88800     }
88801   }
88802 }
88803
88804
88805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88806   void * jresult ;
88807   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88808   int arg2 ;
88809   int arg3 ;
88810   std::vector< Dali::Actor > *result = 0 ;
88811
88812   arg1 = (std::vector< Dali::Actor > *)jarg1;
88813   arg2 = (int)jarg2;
88814   arg3 = (int)jarg3;
88815   {
88816     try {
88817       try {
88818         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88819       }
88820       catch(std::out_of_range &_e) {
88821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88822         return 0;
88823       }
88824       catch(std::invalid_argument &_e) {
88825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88826         return 0;
88827       }
88828
88829     } catch (std::out_of_range& e) {
88830       {
88831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88832       };
88833     } catch (std::exception& e) {
88834       {
88835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88836       };
88837     } catch (...) {
88838       {
88839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88840       };
88841     }
88842   }
88843   jresult = (void *)result;
88844   return jresult;
88845 }
88846
88847
88848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88849   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88850   int arg2 ;
88851   Dali::Actor *arg3 = 0 ;
88852
88853   arg1 = (std::vector< Dali::Actor > *)jarg1;
88854   arg2 = (int)jarg2;
88855   arg3 = (Dali::Actor *)jarg3;
88856   if (!arg3) {
88857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88858     return ;
88859   }
88860   {
88861     try {
88862       try {
88863         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88864       }
88865       catch(std::out_of_range &_e) {
88866         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88867         return ;
88868       }
88869
88870     } catch (std::out_of_range& e) {
88871       {
88872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88873       };
88874     } catch (std::exception& e) {
88875       {
88876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88877       };
88878     } catch (...) {
88879       {
88880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88881       };
88882     }
88883   }
88884 }
88885
88886
88887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88888   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88889   int arg2 ;
88890   std::vector< Dali::Actor > *arg3 = 0 ;
88891
88892   arg1 = (std::vector< Dali::Actor > *)jarg1;
88893   arg2 = (int)jarg2;
88894   arg3 = (std::vector< Dali::Actor > *)jarg3;
88895   if (!arg3) {
88896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88897     return ;
88898   }
88899   {
88900     try {
88901       try {
88902         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88903       }
88904       catch(std::out_of_range &_e) {
88905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88906         return ;
88907       }
88908
88909     } catch (std::out_of_range& e) {
88910       {
88911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88912       };
88913     } catch (std::exception& e) {
88914       {
88915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88916       };
88917     } catch (...) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88920       };
88921     }
88922   }
88923 }
88924
88925
88926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88927   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88928   int arg2 ;
88929
88930   arg1 = (std::vector< Dali::Actor > *)jarg1;
88931   arg2 = (int)jarg2;
88932   {
88933     try {
88934       try {
88935         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88936       }
88937       catch(std::out_of_range &_e) {
88938         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88939         return ;
88940       }
88941
88942     } catch (std::out_of_range& e) {
88943       {
88944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88945       };
88946     } catch (std::exception& e) {
88947       {
88948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88953       };
88954     }
88955   }
88956 }
88957
88958
88959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88960   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88961   int arg2 ;
88962   int arg3 ;
88963
88964   arg1 = (std::vector< Dali::Actor > *)jarg1;
88965   arg2 = (int)jarg2;
88966   arg3 = (int)jarg3;
88967   {
88968     try {
88969       try {
88970         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88971       }
88972       catch(std::out_of_range &_e) {
88973         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88974         return ;
88975       }
88976       catch(std::invalid_argument &_e) {
88977         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88978         return ;
88979       }
88980
88981     } catch (std::out_of_range& e) {
88982       {
88983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88984       };
88985     } catch (std::exception& e) {
88986       {
88987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88988       };
88989     } catch (...) {
88990       {
88991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88992       };
88993     }
88994   }
88995 }
88996
88997
88998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88999   void * jresult ;
89000   Dali::Actor *arg1 = 0 ;
89001   int arg2 ;
89002   std::vector< Dali::Actor > *result = 0 ;
89003
89004   arg1 = (Dali::Actor *)jarg1;
89005   if (!arg1) {
89006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89007     return 0;
89008   }
89009   arg2 = (int)jarg2;
89010   {
89011     try {
89012       try {
89013         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89014       }
89015       catch(std::out_of_range &_e) {
89016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89017         return 0;
89018       }
89019
89020     } catch (std::out_of_range& e) {
89021       {
89022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89023       };
89024     } catch (std::exception& e) {
89025       {
89026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89027       };
89028     } catch (...) {
89029       {
89030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89031       };
89032     }
89033   }
89034   jresult = (void *)result;
89035   return jresult;
89036 }
89037
89038
89039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89040   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89041
89042   arg1 = (std::vector< Dali::Actor > *)jarg1;
89043   {
89044     try {
89045       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89046     } catch (std::out_of_range& e) {
89047       {
89048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89049       };
89050     } catch (std::exception& e) {
89051       {
89052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89053       };
89054     } catch (...) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89057       };
89058     }
89059   }
89060 }
89061
89062
89063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89064   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89065   int arg2 ;
89066   int arg3 ;
89067
89068   arg1 = (std::vector< Dali::Actor > *)jarg1;
89069   arg2 = (int)jarg2;
89070   arg3 = (int)jarg3;
89071   {
89072     try {
89073       try {
89074         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89075       }
89076       catch(std::out_of_range &_e) {
89077         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89078         return ;
89079       }
89080       catch(std::invalid_argument &_e) {
89081         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89082         return ;
89083       }
89084
89085     } catch (std::out_of_range& e) {
89086       {
89087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89088       };
89089     } catch (std::exception& e) {
89090       {
89091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89092       };
89093     } catch (...) {
89094       {
89095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89096       };
89097     }
89098   }
89099 }
89100
89101
89102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89103   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89104   int arg2 ;
89105   std::vector< Dali::Actor > *arg3 = 0 ;
89106
89107   arg1 = (std::vector< Dali::Actor > *)jarg1;
89108   arg2 = (int)jarg2;
89109   arg3 = (std::vector< Dali::Actor > *)jarg3;
89110   if (!arg3) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89112     return ;
89113   }
89114   {
89115     try {
89116       try {
89117         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89118       }
89119       catch(std::out_of_range &_e) {
89120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89121         return ;
89122       }
89123
89124     } catch (std::out_of_range& e) {
89125       {
89126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89127       };
89128     } catch (std::exception& e) {
89129       {
89130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89131       };
89132     } catch (...) {
89133       {
89134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89135       };
89136     }
89137   }
89138 }
89139
89140
89141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89142   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89143
89144   arg1 = (std::vector< Dali::Actor > *)jarg1;
89145   {
89146     try {
89147       delete arg1;
89148     } catch (std::out_of_range& e) {
89149       {
89150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89151       };
89152     } catch (std::exception& e) {
89153       {
89154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89155       };
89156     } catch (...) {
89157       {
89158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89159       };
89160     }
89161   }
89162 }
89163
89164
89165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89166   unsigned int jresult ;
89167   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89168   bool result;
89169
89170   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89171   {
89172     try {
89173       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89181       };
89182     } catch (...) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89185       };
89186     }
89187   }
89188   jresult = result;
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89194   unsigned long jresult ;
89195   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89196   std::size_t result;
89197
89198   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89199   {
89200     try {
89201       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89202     } catch (std::out_of_range& e) {
89203       {
89204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89205       };
89206     } catch (std::exception& e) {
89207       {
89208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89209       };
89210     } catch (...) {
89211       {
89212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89213       };
89214     }
89215   }
89216   jresult = (unsigned long)result;
89217   return jresult;
89218 }
89219
89220
89221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89222   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89223   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89224
89225   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89226   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89227   {
89228     try {
89229       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89230     } catch (std::out_of_range& e) {
89231       {
89232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89233       };
89234     } catch (std::exception& e) {
89235       {
89236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89237       };
89238     } catch (...) {
89239       {
89240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89241       };
89242     }
89243   }
89244 }
89245
89246
89247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89248   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89249   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89250
89251   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89252   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89253   {
89254     try {
89255       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89256     } catch (std::out_of_range& e) {
89257       {
89258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89259       };
89260     } catch (std::exception& e) {
89261       {
89262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89263       };
89264     } catch (...) {
89265       {
89266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89267       };
89268     }
89269   }
89270 }
89271
89272
89273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89274   unsigned int jresult ;
89275   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89276   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89277   bool result;
89278
89279   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89280   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89281   if (!arg2) {
89282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89283     return 0;
89284   }
89285   {
89286     try {
89287       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89288     } catch (std::out_of_range& e) {
89289       {
89290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89291       };
89292     } catch (std::exception& e) {
89293       {
89294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89295       };
89296     } catch (...) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89299       };
89300     }
89301   }
89302   jresult = result;
89303   return jresult;
89304 }
89305
89306
89307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89308   void * jresult ;
89309   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89310
89311   {
89312     try {
89313       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89314     } catch (std::out_of_range& e) {
89315       {
89316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (std::exception& e) {
89319       {
89320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328   jresult = (void *)result;
89329   return jresult;
89330 }
89331
89332
89333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89334   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89335
89336   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89337   {
89338     try {
89339       delete arg1;
89340     } catch (std::out_of_range& e) {
89341       {
89342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89343       };
89344     } catch (std::exception& e) {
89345       {
89346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89347       };
89348     } catch (...) {
89349       {
89350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89351       };
89352     }
89353   }
89354 }
89355
89356
89357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89358   unsigned int jresult ;
89359   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89360   bool result;
89361
89362   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89363   {
89364     try {
89365       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);
89366     } catch (std::out_of_range& e) {
89367       {
89368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89369       };
89370     } catch (std::exception& e) {
89371       {
89372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89373       };
89374     } catch (...) {
89375       {
89376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89377       };
89378     }
89379   }
89380   jresult = result;
89381   return jresult;
89382 }
89383
89384
89385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89386   unsigned long jresult ;
89387   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89388   std::size_t result;
89389
89390   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89391   {
89392     try {
89393       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);
89394     } catch (std::out_of_range& e) {
89395       {
89396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89397       };
89398     } catch (std::exception& e) {
89399       {
89400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89401       };
89402     } catch (...) {
89403       {
89404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89405       };
89406     }
89407   }
89408   jresult = (unsigned long)result;
89409   return jresult;
89410 }
89411
89412
89413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89414   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89415   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89416
89417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89418   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89419   {
89420     try {
89421       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89422     } catch (std::out_of_range& e) {
89423       {
89424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (std::exception& e) {
89427       {
89428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89429       };
89430     } catch (...) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89433       };
89434     }
89435   }
89436 }
89437
89438
89439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89440   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89441   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89442
89443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89444   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89445   {
89446     try {
89447       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89455       };
89456     } catch (...) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89459       };
89460     }
89461   }
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89466   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89467   Dali::Actor arg2 ;
89468   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89469   Dali::Actor *argp2 ;
89470
89471   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89472   argp2 = (Dali::Actor *)jarg2;
89473   if (!argp2) {
89474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89475     return ;
89476   }
89477   arg2 = *argp2;
89478   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89479   {
89480     try {
89481       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89482     } catch (std::out_of_range& e) {
89483       {
89484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89485       };
89486     } catch (std::exception& e) {
89487       {
89488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89489       };
89490     } catch (...) {
89491       {
89492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89493       };
89494     }
89495   }
89496 }
89497
89498
89499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89500   void * jresult ;
89501   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89502
89503   {
89504     try {
89505       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89513       };
89514     } catch (...) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89517       };
89518     }
89519   }
89520   jresult = (void *)result;
89521   return jresult;
89522 }
89523
89524
89525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89526   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89527
89528   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89529   {
89530     try {
89531       delete arg1;
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89543       };
89544     }
89545   }
89546 }
89547
89548
89549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89550   unsigned int jresult ;
89551   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89552   bool result;
89553
89554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89555   {
89556     try {
89557       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89558     } catch (std::out_of_range& e) {
89559       {
89560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89561       };
89562     } catch (std::exception& e) {
89563       {
89564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89565       };
89566     } catch (...) {
89567       {
89568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89569       };
89570     }
89571   }
89572   jresult = result;
89573   return jresult;
89574 }
89575
89576
89577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89578   unsigned long jresult ;
89579   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89580   std::size_t result;
89581
89582   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89583   {
89584     try {
89585       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89586     } catch (std::out_of_range& e) {
89587       {
89588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (std::exception& e) {
89591       {
89592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89593       };
89594     } catch (...) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89597       };
89598     }
89599   }
89600   jresult = (unsigned long)result;
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89606   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89607   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89608
89609   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89610   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89611   {
89612     try {
89613       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89614     } catch (std::out_of_range& e) {
89615       {
89616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89617       };
89618     } catch (std::exception& e) {
89619       {
89620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (...) {
89623       {
89624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89625       };
89626     }
89627   }
89628 }
89629
89630
89631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89632   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89633   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89634
89635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89636   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89637   {
89638     try {
89639       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89640     } catch (std::out_of_range& e) {
89641       {
89642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89643       };
89644     } catch (std::exception& e) {
89645       {
89646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89647       };
89648     } catch (...) {
89649       {
89650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89651       };
89652     }
89653   }
89654 }
89655
89656
89657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89658   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89659   Dali::Actor arg2 ;
89660   Dali::Actor arg3 ;
89661   Dali::Actor *argp2 ;
89662   Dali::Actor *argp3 ;
89663
89664   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89665   argp2 = (Dali::Actor *)jarg2;
89666   if (!argp2) {
89667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89668     return ;
89669   }
89670   arg2 = *argp2;
89671   argp3 = (Dali::Actor *)jarg3;
89672   if (!argp3) {
89673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89674     return ;
89675   }
89676   arg3 = *argp3;
89677   {
89678     try {
89679       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89680     } catch (std::out_of_range& e) {
89681       {
89682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89683       };
89684     } catch (std::exception& e) {
89685       {
89686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89687       };
89688     } catch (...) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89691       };
89692     }
89693   }
89694 }
89695
89696
89697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89698   void * jresult ;
89699   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89700
89701   {
89702     try {
89703       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89704     } catch (std::out_of_range& e) {
89705       {
89706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89707       };
89708     } catch (std::exception& e) {
89709       {
89710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89711       };
89712     } catch (...) {
89713       {
89714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89715       };
89716     }
89717   }
89718   jresult = (void *)result;
89719   return jresult;
89720 }
89721
89722
89723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89724   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89725
89726   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89727   {
89728     try {
89729       delete arg1;
89730     } catch (std::out_of_range& e) {
89731       {
89732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89733       };
89734     } catch (std::exception& e) {
89735       {
89736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89737       };
89738     } catch (...) {
89739       {
89740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89741       };
89742     }
89743   }
89744 }
89745
89746
89747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89748   unsigned int jresult ;
89749   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89750   bool result;
89751
89752   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89753   {
89754     try {
89755       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89756     } catch (std::out_of_range& e) {
89757       {
89758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89759       };
89760     } catch (std::exception& e) {
89761       {
89762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89763       };
89764     } catch (...) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89767       };
89768     }
89769   }
89770   jresult = result;
89771   return jresult;
89772 }
89773
89774
89775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89776   unsigned long jresult ;
89777   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89778   std::size_t result;
89779
89780   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89781   {
89782     try {
89783       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89784     } catch (std::out_of_range& e) {
89785       {
89786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89787       };
89788     } catch (std::exception& e) {
89789       {
89790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89791       };
89792     } catch (...) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89795       };
89796     }
89797   }
89798   jresult = (unsigned long)result;
89799   return jresult;
89800 }
89801
89802
89803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89804   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89805   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89806
89807   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89808   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89809   {
89810     try {
89811       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89812     } catch (std::out_of_range& e) {
89813       {
89814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89815       };
89816     } catch (std::exception& e) {
89817       {
89818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89819       };
89820     } catch (...) {
89821       {
89822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89823       };
89824     }
89825   }
89826 }
89827
89828
89829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89830   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89831   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89832
89833   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89834   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89835   {
89836     try {
89837       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89845       };
89846     } catch (...) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89849       };
89850     }
89851   }
89852 }
89853
89854
89855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89856   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89857   Dali::Actor arg2 ;
89858   bool arg3 ;
89859   Dali::Actor *argp2 ;
89860
89861   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89862   argp2 = (Dali::Actor *)jarg2;
89863   if (!argp2) {
89864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89865     return ;
89866   }
89867   arg2 = *argp2;
89868   arg3 = jarg3 ? true : false;
89869   {
89870     try {
89871       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89872     } catch (std::out_of_range& e) {
89873       {
89874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89875       };
89876     } catch (std::exception& e) {
89877       {
89878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89879       };
89880     } catch (...) {
89881       {
89882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89883       };
89884     }
89885   }
89886 }
89887
89888
89889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89890   void * jresult ;
89891   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89892
89893   {
89894     try {
89895       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89896     } catch (std::out_of_range& e) {
89897       {
89898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89899       };
89900     } catch (std::exception& e) {
89901       {
89902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89903       };
89904     } catch (...) {
89905       {
89906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89907       };
89908     }
89909   }
89910   jresult = (void *)result;
89911   return jresult;
89912 }
89913
89914
89915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89916   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89917
89918   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89919   {
89920     try {
89921       delete arg1;
89922     } catch (std::out_of_range& e) {
89923       {
89924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89925       };
89926     } catch (std::exception& e) {
89927       {
89928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89929       };
89930     } catch (...) {
89931       {
89932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89933       };
89934     }
89935   }
89936 }
89937
89938
89939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89940   unsigned int jresult ;
89941   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89942   bool result;
89943
89944   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89945   {
89946     try {
89947       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);
89948     } catch (std::out_of_range& e) {
89949       {
89950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89951       };
89952     } catch (std::exception& e) {
89953       {
89954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89955       };
89956     } catch (...) {
89957       {
89958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89959       };
89960     }
89961   }
89962   jresult = result;
89963   return jresult;
89964 }
89965
89966
89967 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89968   unsigned long jresult ;
89969   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89970   std::size_t result;
89971
89972   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89973   {
89974     try {
89975       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);
89976     } catch (std::out_of_range& e) {
89977       {
89978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89979       };
89980     } catch (std::exception& e) {
89981       {
89982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89983       };
89984     } catch (...) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89987       };
89988     }
89989   }
89990   jresult = (unsigned long)result;
89991   return jresult;
89992 }
89993
89994
89995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89996   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89997   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89998
89999   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90000   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90001   {
90002     try {
90003       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90004     } catch (std::out_of_range& e) {
90005       {
90006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (std::exception& e) {
90009       {
90010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018 }
90019
90020
90021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90022   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90023   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90024
90025   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90026   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90027   {
90028     try {
90029       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90041       };
90042     }
90043   }
90044 }
90045
90046
90047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90048   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90049   Dali::Toolkit::StyleManager arg2 ;
90050   Dali::StyleChange::Type arg3 ;
90051   Dali::Toolkit::StyleManager *argp2 ;
90052
90053   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90054   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90055   if (!argp2) {
90056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90057     return ;
90058   }
90059   arg2 = *argp2;
90060   arg3 = (Dali::StyleChange::Type)jarg3;
90061   {
90062     try {
90063       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90064     } catch (std::out_of_range& e) {
90065       {
90066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90067       };
90068     } catch (std::exception& e) {
90069       {
90070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90075       };
90076     }
90077   }
90078 }
90079
90080
90081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90082   void * jresult ;
90083   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90084
90085   {
90086     try {
90087       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90088     } catch (std::out_of_range& e) {
90089       {
90090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90091       };
90092     } catch (std::exception& e) {
90093       {
90094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90095       };
90096     } catch (...) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90099       };
90100     }
90101   }
90102   jresult = (void *)result;
90103   return jresult;
90104 }
90105
90106
90107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90108   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90109
90110   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90111   {
90112     try {
90113       delete arg1;
90114     } catch (std::out_of_range& e) {
90115       {
90116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90117       };
90118     } catch (std::exception& e) {
90119       {
90120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90121       };
90122     } catch (...) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90125       };
90126     }
90127   }
90128 }
90129
90130
90131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90132   unsigned int jresult ;
90133   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90134   bool result;
90135
90136   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90137   {
90138     try {
90139       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90140     } catch (std::out_of_range& e) {
90141       {
90142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90143       };
90144     } catch (std::exception& e) {
90145       {
90146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90151       };
90152     }
90153   }
90154   jresult = result;
90155   return jresult;
90156 }
90157
90158
90159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90160   unsigned long jresult ;
90161   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90162   std::size_t result;
90163
90164   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90165   {
90166     try {
90167       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90168     } catch (std::out_of_range& e) {
90169       {
90170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90171       };
90172     } catch (std::exception& e) {
90173       {
90174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90175       };
90176     } catch (...) {
90177       {
90178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90179       };
90180     }
90181   }
90182   jresult = (unsigned long)result;
90183   return jresult;
90184 }
90185
90186
90187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90188   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90189   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90190
90191   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90192   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90193   {
90194     try {
90195       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90196     } catch (std::out_of_range& e) {
90197       {
90198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90199       };
90200     } catch (std::exception& e) {
90201       {
90202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90203       };
90204     } catch (...) {
90205       {
90206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90207       };
90208     }
90209   }
90210 }
90211
90212
90213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90214   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90215   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90216
90217   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90218   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90219   {
90220     try {
90221       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90222     } catch (std::out_of_range& e) {
90223       {
90224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90225       };
90226     } catch (std::exception& e) {
90227       {
90228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90229       };
90230     } catch (...) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90233       };
90234     }
90235   }
90236 }
90237
90238
90239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90240   unsigned int jresult ;
90241   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90242   Dali::Toolkit::Button arg2 ;
90243   Dali::Toolkit::Button *argp2 ;
90244   bool result;
90245
90246   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90247   argp2 = (Dali::Toolkit::Button *)jarg2;
90248   if (!argp2) {
90249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90250     return 0;
90251   }
90252   arg2 = *argp2;
90253   {
90254     try {
90255       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90263       };
90264     } catch (...) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90267       };
90268     }
90269   }
90270   jresult = result;
90271   return jresult;
90272 }
90273
90274
90275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90276   void * jresult ;
90277   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90278
90279   {
90280     try {
90281       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90282     } catch (std::out_of_range& e) {
90283       {
90284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (std::exception& e) {
90287       {
90288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90293       };
90294     }
90295   }
90296   jresult = (void *)result;
90297   return jresult;
90298 }
90299
90300
90301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90302   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90303
90304   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90305   {
90306     try {
90307       delete arg1;
90308     } catch (std::out_of_range& e) {
90309       {
90310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90311       };
90312     } catch (std::exception& e) {
90313       {
90314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90315       };
90316     } catch (...) {
90317       {
90318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90319       };
90320     }
90321   }
90322 }
90323
90324
90325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90326   unsigned int jresult ;
90327   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90328   bool result;
90329
90330   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90331   {
90332     try {
90333       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90334     } catch (std::out_of_range& e) {
90335       {
90336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90337       };
90338     } catch (std::exception& e) {
90339       {
90340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90345       };
90346     }
90347   }
90348   jresult = result;
90349   return jresult;
90350 }
90351
90352
90353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90354   unsigned long jresult ;
90355   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90356   std::size_t result;
90357
90358   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90359   {
90360     try {
90361       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90362     } catch (std::out_of_range& e) {
90363       {
90364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (std::exception& e) {
90367       {
90368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90369       };
90370     } catch (...) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90373       };
90374     }
90375   }
90376   jresult = (unsigned long)result;
90377   return jresult;
90378 }
90379
90380
90381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90382   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90383   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90384
90385   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90386   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90387   {
90388     try {
90389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90390     } catch (std::out_of_range& e) {
90391       {
90392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90393       };
90394     } catch (std::exception& e) {
90395       {
90396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90397       };
90398     } catch (...) {
90399       {
90400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90401       };
90402     }
90403   }
90404 }
90405
90406
90407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90408   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90409   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90410
90411   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90412   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90413   {
90414     try {
90415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90423       };
90424     } catch (...) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90427       };
90428     }
90429   }
90430 }
90431
90432
90433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90434   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90435   Dali::Toolkit::GaussianBlurView arg2 ;
90436   Dali::Toolkit::GaussianBlurView *argp2 ;
90437
90438   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90439   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90440   if (!argp2) {
90441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90442     return ;
90443   }
90444   arg2 = *argp2;
90445   {
90446     try {
90447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90448     } catch (std::out_of_range& e) {
90449       {
90450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90451       };
90452     } catch (std::exception& e) {
90453       {
90454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90455       };
90456     } catch (...) {
90457       {
90458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90459       };
90460     }
90461   }
90462 }
90463
90464
90465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90466   void * jresult ;
90467   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90468
90469   {
90470     try {
90471       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90472     } catch (std::out_of_range& e) {
90473       {
90474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90475       };
90476     } catch (std::exception& e) {
90477       {
90478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90479       };
90480     } catch (...) {
90481       {
90482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90483       };
90484     }
90485   }
90486   jresult = (void *)result;
90487   return jresult;
90488 }
90489
90490
90491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90492   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90493
90494   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90495   {
90496     try {
90497       delete arg1;
90498     } catch (std::out_of_range& e) {
90499       {
90500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90501       };
90502     } catch (std::exception& e) {
90503       {
90504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90509       };
90510     }
90511   }
90512 }
90513
90514
90515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90516   unsigned int jresult ;
90517   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90518   bool result;
90519
90520   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90521   {
90522     try {
90523       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);
90524     } catch (std::out_of_range& e) {
90525       {
90526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90527       };
90528     } catch (std::exception& e) {
90529       {
90530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90531       };
90532     } catch (...) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90535       };
90536     }
90537   }
90538   jresult = result;
90539   return jresult;
90540 }
90541
90542
90543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90544   unsigned long jresult ;
90545   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90546   std::size_t result;
90547
90548   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90549   {
90550     try {
90551       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);
90552     } catch (std::out_of_range& e) {
90553       {
90554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90555       };
90556     } catch (std::exception& e) {
90557       {
90558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90559       };
90560     } catch (...) {
90561       {
90562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90563       };
90564     }
90565   }
90566   jresult = (unsigned long)result;
90567   return jresult;
90568 }
90569
90570
90571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90572   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90573   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90574
90575   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90576   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90577   {
90578     try {
90579       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90580     } catch (std::out_of_range& e) {
90581       {
90582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90583       };
90584     } catch (std::exception& e) {
90585       {
90586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90587       };
90588     } catch (...) {
90589       {
90590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90591       };
90592     }
90593   }
90594 }
90595
90596
90597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90598   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90599   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90600
90601   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90602   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90603   {
90604     try {
90605       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90606     } catch (std::out_of_range& e) {
90607       {
90608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90609       };
90610     } catch (std::exception& e) {
90611       {
90612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90613       };
90614     } catch (...) {
90615       {
90616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90617       };
90618     }
90619   }
90620 }
90621
90622
90623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90624   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90625   Dali::Toolkit::PageTurnView arg2 ;
90626   unsigned int arg3 ;
90627   bool arg4 ;
90628   Dali::Toolkit::PageTurnView *argp2 ;
90629
90630   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90631   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90632   if (!argp2) {
90633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90634     return ;
90635   }
90636   arg2 = *argp2;
90637   arg3 = (unsigned int)jarg3;
90638   arg4 = jarg4 ? true : false;
90639   {
90640     try {
90641       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90642     } catch (std::out_of_range& e) {
90643       {
90644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90645       };
90646     } catch (std::exception& e) {
90647       {
90648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90649       };
90650     } catch (...) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90653       };
90654     }
90655   }
90656 }
90657
90658
90659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90660   void * jresult ;
90661   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90662
90663   {
90664     try {
90665       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90666     } catch (std::out_of_range& e) {
90667       {
90668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90669       };
90670     } catch (std::exception& e) {
90671       {
90672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90673       };
90674     } catch (...) {
90675       {
90676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90677       };
90678     }
90679   }
90680   jresult = (void *)result;
90681   return jresult;
90682 }
90683
90684
90685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90686   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90687
90688   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90689   {
90690     try {
90691       delete arg1;
90692     } catch (std::out_of_range& e) {
90693       {
90694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90695       };
90696     } catch (std::exception& e) {
90697       {
90698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90699       };
90700     } catch (...) {
90701       {
90702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90703       };
90704     }
90705   }
90706 }
90707
90708
90709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90710   unsigned int jresult ;
90711   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90712   bool result;
90713
90714   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90715   {
90716     try {
90717       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (...) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90729       };
90730     }
90731   }
90732   jresult = result;
90733   return jresult;
90734 }
90735
90736
90737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90738   unsigned long jresult ;
90739   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90740   std::size_t result;
90741
90742   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90743   {
90744     try {
90745       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90746     } catch (std::out_of_range& e) {
90747       {
90748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90749       };
90750     } catch (std::exception& e) {
90751       {
90752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90753       };
90754     } catch (...) {
90755       {
90756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90757       };
90758     }
90759   }
90760   jresult = (unsigned long)result;
90761   return jresult;
90762 }
90763
90764
90765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90766   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90767   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90768
90769   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90770   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90771   {
90772     try {
90773       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90774     } catch (std::out_of_range& e) {
90775       {
90776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90777       };
90778     } catch (std::exception& e) {
90779       {
90780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90781       };
90782     } catch (...) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90785       };
90786     }
90787   }
90788 }
90789
90790
90791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90792   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90793   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90794
90795   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90796   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90797   {
90798     try {
90799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90800     } catch (std::out_of_range& e) {
90801       {
90802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90803       };
90804     } catch (std::exception& e) {
90805       {
90806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90807       };
90808     } catch (...) {
90809       {
90810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90811       };
90812     }
90813   }
90814 }
90815
90816
90817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90818   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90819   Dali::Toolkit::PageTurnView arg2 ;
90820   Dali::Toolkit::PageTurnView *argp2 ;
90821
90822   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90823   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90824   if (!argp2) {
90825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90826     return ;
90827   }
90828   arg2 = *argp2;
90829   {
90830     try {
90831       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90832     } catch (std::out_of_range& e) {
90833       {
90834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90835       };
90836     } catch (std::exception& e) {
90837       {
90838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90839       };
90840     } catch (...) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90843       };
90844     }
90845   }
90846 }
90847
90848
90849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90850   void * jresult ;
90851   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90852
90853   {
90854     try {
90855       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (...) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90867       };
90868     }
90869   }
90870   jresult = (void *)result;
90871   return jresult;
90872 }
90873
90874
90875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90876   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90877
90878   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90879   {
90880     try {
90881       delete arg1;
90882     } catch (std::out_of_range& e) {
90883       {
90884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90885       };
90886     } catch (std::exception& e) {
90887       {
90888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90889       };
90890     } catch (...) {
90891       {
90892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90893       };
90894     }
90895   }
90896 }
90897
90898
90899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
90900   unsigned int jresult ;
90901   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90902   bool result;
90903
90904   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90905   {
90906     try {
90907       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);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (...) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90919       };
90920     }
90921   }
90922   jresult = result;
90923   return jresult;
90924 }
90925
90926
90927 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
90928   unsigned long jresult ;
90929   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90930   std::size_t result;
90931
90932   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90933   {
90934     try {
90935       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);
90936     } catch (std::out_of_range& e) {
90937       {
90938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (std::exception& e) {
90941       {
90942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90947       };
90948     }
90949   }
90950   jresult = (unsigned long)result;
90951   return jresult;
90952 }
90953
90954
90955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90956   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90957   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90958
90959   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90960   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90961   {
90962     try {
90963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90964     } catch (std::out_of_range& e) {
90965       {
90966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90967       };
90968     } catch (std::exception& e) {
90969       {
90970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90971       };
90972     } catch (...) {
90973       {
90974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90975       };
90976     }
90977   }
90978 }
90979
90980
90981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90982   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90983   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90984
90985   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90986   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90987   {
90988     try {
90989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90990     } catch (std::out_of_range& e) {
90991       {
90992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90993       };
90994     } catch (std::exception& e) {
90995       {
90996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90997       };
90998     } catch (...) {
90999       {
91000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91001       };
91002     }
91003   }
91004 }
91005
91006
91007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91008   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91009   Dali::Toolkit::ProgressBar arg2 ;
91010   float arg3 ;
91011   float arg4 ;
91012   Dali::Toolkit::ProgressBar *argp2 ;
91013
91014   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91015   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91016   if (!argp2) {
91017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91018     return ;
91019   }
91020   arg2 = *argp2;
91021   arg3 = (float)jarg3;
91022   arg4 = (float)jarg4;
91023   {
91024     try {
91025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91026     } catch (std::out_of_range& e) {
91027       {
91028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91029       };
91030     } catch (std::exception& e) {
91031       {
91032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91033       };
91034     } catch (...) {
91035       {
91036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91037       };
91038     }
91039   }
91040 }
91041
91042
91043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91044   void * jresult ;
91045   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91046
91047   {
91048     try {
91049       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91050     } catch (std::out_of_range& e) {
91051       {
91052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91053       };
91054     } catch (std::exception& e) {
91055       {
91056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91057       };
91058     } catch (...) {
91059       {
91060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91061       };
91062     }
91063   }
91064   jresult = (void *)result;
91065   return jresult;
91066 }
91067
91068
91069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91070   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91071
91072   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91073   {
91074     try {
91075       delete arg1;
91076     } catch (std::out_of_range& e) {
91077       {
91078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91079       };
91080     } catch (std::exception& e) {
91081       {
91082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91083       };
91084     } catch (...) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91087       };
91088     }
91089   }
91090 }
91091
91092
91093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91094   unsigned int jresult ;
91095   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91096   bool result;
91097
91098   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91099   {
91100     try {
91101       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);
91102     } catch (std::out_of_range& e) {
91103       {
91104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91105       };
91106     } catch (std::exception& e) {
91107       {
91108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91109       };
91110     } catch (...) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91113       };
91114     }
91115   }
91116   jresult = result;
91117   return jresult;
91118 }
91119
91120
91121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91122   unsigned long jresult ;
91123   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91124   std::size_t result;
91125
91126   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91127   {
91128     try {
91129       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);
91130     } catch (std::out_of_range& e) {
91131       {
91132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91133       };
91134     } catch (std::exception& e) {
91135       {
91136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91137       };
91138     } catch (...) {
91139       {
91140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91141       };
91142     }
91143   }
91144   jresult = (unsigned long)result;
91145   return jresult;
91146 }
91147
91148
91149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91150   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91151   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91152
91153   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91154   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91155   {
91156     try {
91157       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91158     } catch (std::out_of_range& e) {
91159       {
91160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91161       };
91162     } catch (std::exception& e) {
91163       {
91164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91165       };
91166     } catch (...) {
91167       {
91168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91169       };
91170     }
91171   }
91172 }
91173
91174
91175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91176   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91177   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91178
91179   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91180   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91181   {
91182     try {
91183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91184     } catch (std::out_of_range& e) {
91185       {
91186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91187       };
91188     } catch (std::exception& e) {
91189       {
91190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91195       };
91196     }
91197   }
91198 }
91199
91200
91201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91202   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91203   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91204
91205   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91206   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91207   if (!arg2) {
91208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91209     return ;
91210   }
91211   {
91212     try {
91213       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91214     } catch (std::out_of_range& e) {
91215       {
91216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (std::exception& e) {
91219       {
91220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91221       };
91222     } catch (...) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91225       };
91226     }
91227   }
91228 }
91229
91230
91231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91232   void * jresult ;
91233   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91234
91235   {
91236     try {
91237       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91238     } catch (std::out_of_range& e) {
91239       {
91240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91241       };
91242     } catch (std::exception& e) {
91243       {
91244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91245       };
91246     } catch (...) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91249       };
91250     }
91251   }
91252   jresult = (void *)result;
91253   return jresult;
91254 }
91255
91256
91257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91258   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91259
91260   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91261   {
91262     try {
91263       delete arg1;
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91271       };
91272     } catch (...) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91275       };
91276     }
91277   }
91278 }
91279
91280
91281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91282   unsigned int jresult ;
91283   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91284   bool result;
91285
91286   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91287   {
91288     try {
91289       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91290     } catch (std::out_of_range& e) {
91291       {
91292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91293       };
91294     } catch (std::exception& e) {
91295       {
91296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91297       };
91298     } catch (...) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91301       };
91302     }
91303   }
91304   jresult = result;
91305   return jresult;
91306 }
91307
91308
91309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91310   unsigned long jresult ;
91311   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91312   std::size_t result;
91313
91314   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91315   {
91316     try {
91317       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91318     } catch (std::out_of_range& e) {
91319       {
91320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91321       };
91322     } catch (std::exception& e) {
91323       {
91324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91325       };
91326     } catch (...) {
91327       {
91328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91329       };
91330     }
91331   }
91332   jresult = (unsigned long)result;
91333   return jresult;
91334 }
91335
91336
91337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91338   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91339   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91340
91341   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91342   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91343   {
91344     try {
91345       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91346     } catch (std::out_of_range& e) {
91347       {
91348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91349       };
91350     } catch (std::exception& e) {
91351       {
91352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91353       };
91354     } catch (...) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91357       };
91358     }
91359   }
91360 }
91361
91362
91363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91364   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91365   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91366
91367   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91368   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91369   {
91370     try {
91371       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91372     } catch (std::out_of_range& e) {
91373       {
91374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91375       };
91376     } catch (std::exception& e) {
91377       {
91378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91379       };
91380     } catch (...) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91383       };
91384     }
91385   }
91386 }
91387
91388
91389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91390   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91391   Dali::Vector2 *arg2 = 0 ;
91392
91393   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91394   arg2 = (Dali::Vector2 *)jarg2;
91395   if (!arg2) {
91396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91397     return ;
91398   }
91399   {
91400     try {
91401       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91402     } catch (std::out_of_range& e) {
91403       {
91404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91405       };
91406     } catch (std::exception& e) {
91407       {
91408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91409       };
91410     } catch (...) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91413       };
91414     }
91415   }
91416 }
91417
91418
91419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91420   void * jresult ;
91421   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91422
91423   {
91424     try {
91425       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91426     } catch (std::out_of_range& e) {
91427       {
91428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91429       };
91430     } catch (std::exception& e) {
91431       {
91432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91433       };
91434     } catch (...) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91437       };
91438     }
91439   }
91440   jresult = (void *)result;
91441   return jresult;
91442 }
91443
91444
91445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91446   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91447
91448   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91449   {
91450     try {
91451       delete arg1;
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91459       };
91460     } catch (...) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91463       };
91464     }
91465   }
91466 }
91467
91468
91469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91470   unsigned int jresult ;
91471   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91472   bool result;
91473
91474   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91475   {
91476     try {
91477       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91478     } catch (std::out_of_range& e) {
91479       {
91480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91481       };
91482     } catch (std::exception& e) {
91483       {
91484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (...) {
91487       {
91488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91489       };
91490     }
91491   }
91492   jresult = result;
91493   return jresult;
91494 }
91495
91496
91497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91498   unsigned long jresult ;
91499   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91500   std::size_t result;
91501
91502   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91503   {
91504     try {
91505       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91506     } catch (std::out_of_range& e) {
91507       {
91508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91509       };
91510     } catch (std::exception& e) {
91511       {
91512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91513       };
91514     } catch (...) {
91515       {
91516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91517       };
91518     }
91519   }
91520   jresult = (unsigned long)result;
91521   return jresult;
91522 }
91523
91524
91525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91526   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91527   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91528
91529   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91530   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91531   {
91532     try {
91533       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91534     } catch (std::out_of_range& e) {
91535       {
91536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91537       };
91538     } catch (std::exception& e) {
91539       {
91540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91541       };
91542     } catch (...) {
91543       {
91544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91545       };
91546     }
91547   }
91548 }
91549
91550
91551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91552   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91553   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91554
91555   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91556   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91557   {
91558     try {
91559       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91560     } catch (std::out_of_range& e) {
91561       {
91562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91563       };
91564     } catch (std::exception& e) {
91565       {
91566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91571       };
91572     }
91573   }
91574 }
91575
91576
91577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91578   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91579   Dali::Toolkit::TextEditor arg2 ;
91580   Dali::Toolkit::TextEditor *argp2 ;
91581
91582   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91583   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91584   if (!argp2) {
91585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91586     return ;
91587   }
91588   arg2 = *argp2;
91589   {
91590     try {
91591       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91592     } catch (std::out_of_range& e) {
91593       {
91594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91595       };
91596     } catch (std::exception& e) {
91597       {
91598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91599       };
91600     } catch (...) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91603       };
91604     }
91605   }
91606 }
91607
91608
91609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91610   void * jresult ;
91611   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91612
91613   {
91614     try {
91615       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91623       };
91624     } catch (...) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91627       };
91628     }
91629   }
91630   jresult = (void *)result;
91631   return jresult;
91632 }
91633
91634
91635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91636   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91637
91638   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91639   {
91640     try {
91641       delete arg1;
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91649       };
91650     } catch (...) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91653       };
91654     }
91655   }
91656 }
91657
91658
91659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91660   unsigned int jresult ;
91661   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91662   bool result;
91663
91664   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91665   {
91666     try {
91667       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91668     } catch (std::out_of_range& e) {
91669       {
91670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91671       };
91672     } catch (std::exception& e) {
91673       {
91674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91679       };
91680     }
91681   }
91682   jresult = result;
91683   return jresult;
91684 }
91685
91686
91687 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91688   unsigned long jresult ;
91689   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91690   std::size_t result;
91691
91692   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91693   {
91694     try {
91695       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91696     } catch (std::out_of_range& e) {
91697       {
91698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91699       };
91700     } catch (std::exception& e) {
91701       {
91702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91703       };
91704     } catch (...) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91707       };
91708     }
91709   }
91710   jresult = (unsigned long)result;
91711   return jresult;
91712 }
91713
91714
91715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91716   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91717   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91718
91719   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91720   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91721   {
91722     try {
91723       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91724     } catch (std::out_of_range& e) {
91725       {
91726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91727       };
91728     } catch (std::exception& e) {
91729       {
91730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91731       };
91732     } catch (...) {
91733       {
91734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91735       };
91736     }
91737   }
91738 }
91739
91740
91741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91742   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91743   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91744
91745   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91746   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91747   {
91748     try {
91749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91750     } catch (std::out_of_range& e) {
91751       {
91752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91753       };
91754     } catch (std::exception& e) {
91755       {
91756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91757       };
91758     } catch (...) {
91759       {
91760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91761       };
91762     }
91763   }
91764 }
91765
91766
91767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91768   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91769   Dali::Toolkit::TextField arg2 ;
91770   Dali::Toolkit::TextField *argp2 ;
91771
91772   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91773   argp2 = (Dali::Toolkit::TextField *)jarg2;
91774   if (!argp2) {
91775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91776     return ;
91777   }
91778   arg2 = *argp2;
91779   {
91780     try {
91781       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91782     } catch (std::out_of_range& e) {
91783       {
91784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91785       };
91786     } catch (std::exception& e) {
91787       {
91788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91789       };
91790     } catch (...) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91793       };
91794     }
91795   }
91796 }
91797
91798
91799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91800   void * jresult ;
91801   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91802
91803   {
91804     try {
91805       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91806     } catch (std::out_of_range& e) {
91807       {
91808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91809       };
91810     } catch (std::exception& e) {
91811       {
91812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91813       };
91814     } catch (...) {
91815       {
91816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91817       };
91818     }
91819   }
91820   jresult = (void *)result;
91821   return jresult;
91822 }
91823
91824
91825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91826   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91827
91828   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91829   {
91830     try {
91831       delete arg1;
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91843       };
91844     }
91845   }
91846 }
91847
91848
91849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91850   unsigned int jresult ;
91851   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91852   bool result;
91853
91854   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91855   {
91856     try {
91857       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);
91858     } catch (std::out_of_range& e) {
91859       {
91860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91861       };
91862     } catch (std::exception& e) {
91863       {
91864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91865       };
91866     } catch (...) {
91867       {
91868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91869       };
91870     }
91871   }
91872   jresult = result;
91873   return jresult;
91874 }
91875
91876
91877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91878   unsigned long jresult ;
91879   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91880   std::size_t result;
91881
91882   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91883   {
91884     try {
91885       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);
91886     } catch (std::out_of_range& e) {
91887       {
91888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91889       };
91890     } catch (std::exception& e) {
91891       {
91892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91893       };
91894     } catch (...) {
91895       {
91896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91897       };
91898     }
91899   }
91900   jresult = (unsigned long)result;
91901   return jresult;
91902 }
91903
91904
91905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91906   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91907   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91908
91909   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91910   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91911   {
91912     try {
91913       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91914     } catch (std::out_of_range& e) {
91915       {
91916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91917       };
91918     } catch (std::exception& e) {
91919       {
91920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91921       };
91922     } catch (...) {
91923       {
91924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91925       };
91926     }
91927   }
91928 }
91929
91930
91931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91932   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91933   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91934
91935   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91936   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91937   {
91938     try {
91939       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91940     } catch (std::out_of_range& e) {
91941       {
91942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91943       };
91944     } catch (std::exception& e) {
91945       {
91946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91947       };
91948     } catch (...) {
91949       {
91950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91951       };
91952     }
91953   }
91954 }
91955
91956
91957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91958   unsigned int jresult ;
91959   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91960   Dali::Toolkit::Control arg2 ;
91961   Dali::KeyEvent *arg3 = 0 ;
91962   Dali::Toolkit::Control *argp2 ;
91963   bool result;
91964
91965   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91966   argp2 = (Dali::Toolkit::Control *)jarg2;
91967   if (!argp2) {
91968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91969     return 0;
91970   }
91971   arg2 = *argp2;
91972   arg3 = (Dali::KeyEvent *)jarg3;
91973   if (!arg3) {
91974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91975     return 0;
91976   }
91977   {
91978     try {
91979       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);
91980     } catch (std::out_of_range& e) {
91981       {
91982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91983       };
91984     } catch (std::exception& e) {
91985       {
91986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91987       };
91988     } catch (...) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91991       };
91992     }
91993   }
91994   jresult = result;
91995   return jresult;
91996 }
91997
91998
91999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92000   void * jresult ;
92001   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92002
92003   {
92004     try {
92005       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92006     } catch (std::out_of_range& e) {
92007       {
92008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92009       };
92010     } catch (std::exception& e) {
92011       {
92012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92013       };
92014     } catch (...) {
92015       {
92016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92017       };
92018     }
92019   }
92020   jresult = (void *)result;
92021   return jresult;
92022 }
92023
92024
92025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92026   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92027
92028   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92029   {
92030     try {
92031       delete arg1;
92032     } catch (std::out_of_range& e) {
92033       {
92034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92035       };
92036     } catch (std::exception& e) {
92037       {
92038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92039       };
92040     } catch (...) {
92041       {
92042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92043       };
92044     }
92045   }
92046 }
92047
92048
92049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92050   unsigned int jresult ;
92051   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92052   bool result;
92053
92054   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92055   {
92056     try {
92057       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92058     } catch (std::out_of_range& e) {
92059       {
92060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92061       };
92062     } catch (std::exception& e) {
92063       {
92064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92065       };
92066     } catch (...) {
92067       {
92068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92069       };
92070     }
92071   }
92072   jresult = result;
92073   return jresult;
92074 }
92075
92076
92077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92078   unsigned long jresult ;
92079   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92080   std::size_t result;
92081
92082   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92083   {
92084     try {
92085       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92086     } catch (std::out_of_range& e) {
92087       {
92088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (std::exception& e) {
92091       {
92092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100   jresult = (unsigned long)result;
92101   return jresult;
92102 }
92103
92104
92105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92106   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92107   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92108
92109   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92110   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92111   {
92112     try {
92113       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92114     } catch (std::out_of_range& e) {
92115       {
92116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92117       };
92118     } catch (std::exception& e) {
92119       {
92120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92121       };
92122     } catch (...) {
92123       {
92124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92125       };
92126     }
92127   }
92128 }
92129
92130
92131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92132   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92133   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92134
92135   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92136   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92137   {
92138     try {
92139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92140     } catch (std::out_of_range& e) {
92141       {
92142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92143       };
92144     } catch (std::exception& e) {
92145       {
92146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92147       };
92148     } catch (...) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92151       };
92152     }
92153   }
92154 }
92155
92156
92157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92158   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92159   Dali::Toolkit::Control arg2 ;
92160   Dali::Toolkit::Control *argp2 ;
92161
92162   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92163   argp2 = (Dali::Toolkit::Control *)jarg2;
92164   if (!argp2) {
92165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92166     return ;
92167   }
92168   arg2 = *argp2;
92169   {
92170     try {
92171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92172     } catch (std::out_of_range& e) {
92173       {
92174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92175       };
92176     } catch (std::exception& e) {
92177       {
92178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92179       };
92180     } catch (...) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92183       };
92184     }
92185   }
92186 }
92187
92188
92189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92190   void * jresult ;
92191   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92192
92193   {
92194     try {
92195       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92196     } catch (std::out_of_range& e) {
92197       {
92198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92199       };
92200     } catch (std::exception& e) {
92201       {
92202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92203       };
92204     } catch (...) {
92205       {
92206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92207       };
92208     }
92209   }
92210   jresult = (void *)result;
92211   return jresult;
92212 }
92213
92214
92215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92216   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92217
92218   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92219   {
92220     try {
92221       delete arg1;
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92229       };
92230     } catch (...) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92233       };
92234     }
92235   }
92236 }
92237
92238
92239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92240   unsigned int jresult ;
92241   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92242   bool result;
92243
92244   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92245   {
92246     try {
92247       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92248     } catch (std::out_of_range& e) {
92249       {
92250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92251       };
92252     } catch (std::exception& e) {
92253       {
92254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (...) {
92257       {
92258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92259       };
92260     }
92261   }
92262   jresult = result;
92263   return jresult;
92264 }
92265
92266
92267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92268   unsigned long jresult ;
92269   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92270   std::size_t result;
92271
92272   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92273   {
92274     try {
92275       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92276     } catch (std::out_of_range& e) {
92277       {
92278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92279       };
92280     } catch (std::exception& e) {
92281       {
92282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92283       };
92284     } catch (...) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92287       };
92288     }
92289   }
92290   jresult = (unsigned long)result;
92291   return jresult;
92292 }
92293
92294
92295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92296   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92297   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92298
92299   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92300   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92301   {
92302     try {
92303       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92304     } catch (std::out_of_range& e) {
92305       {
92306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92307       };
92308     } catch (std::exception& e) {
92309       {
92310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92311       };
92312     } catch (...) {
92313       {
92314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92315       };
92316     }
92317   }
92318 }
92319
92320
92321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92322   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92323   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92324
92325   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92326   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92327   {
92328     try {
92329       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92330     } catch (std::out_of_range& e) {
92331       {
92332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92333       };
92334     } catch (std::exception& e) {
92335       {
92336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92337       };
92338     } catch (...) {
92339       {
92340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92341       };
92342     }
92343   }
92344 }
92345
92346
92347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92348   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92349   Dali::Toolkit::VideoView *arg2 = 0 ;
92350
92351   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92352   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92353   if (!arg2) {
92354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92355     return ;
92356   }
92357   {
92358     try {
92359       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92360     } catch (std::out_of_range& e) {
92361       {
92362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92363       };
92364     } catch (std::exception& e) {
92365       {
92366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92367       };
92368     } catch (...) {
92369       {
92370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92371       };
92372     }
92373   }
92374 }
92375
92376
92377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92378   void * jresult ;
92379   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92380
92381   {
92382     try {
92383       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92384     } catch (std::out_of_range& e) {
92385       {
92386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (std::exception& e) {
92389       {
92390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92391       };
92392     } catch (...) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92395       };
92396     }
92397   }
92398   jresult = (void *)result;
92399   return jresult;
92400 }
92401
92402
92403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92404   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92405
92406   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92407   {
92408     try {
92409       delete arg1;
92410     } catch (std::out_of_range& e) {
92411       {
92412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92413       };
92414     } catch (std::exception& e) {
92415       {
92416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92417       };
92418     } catch (...) {
92419       {
92420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92421       };
92422     }
92423   }
92424 }
92425
92426
92427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92428   unsigned int jresult ;
92429   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92430   bool result;
92431
92432   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92433   {
92434     try {
92435       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92436     } catch (std::out_of_range& e) {
92437       {
92438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92439       };
92440     } catch (std::exception& e) {
92441       {
92442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92447       };
92448     }
92449   }
92450   jresult = result;
92451   return jresult;
92452 }
92453
92454
92455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92456   unsigned long jresult ;
92457   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92458   std::size_t result;
92459
92460   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92461   {
92462     try {
92463       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92464     } catch (std::out_of_range& e) {
92465       {
92466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92467       };
92468     } catch (std::exception& e) {
92469       {
92470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92471       };
92472     } catch (...) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92475       };
92476     }
92477   }
92478   jresult = (unsigned long)result;
92479   return jresult;
92480 }
92481
92482
92483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92484   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92485   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92486
92487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92488   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92489   {
92490     try {
92491       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92492     } catch (std::out_of_range& e) {
92493       {
92494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92495       };
92496     } catch (std::exception& e) {
92497       {
92498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92499       };
92500     } catch (...) {
92501       {
92502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92503       };
92504     }
92505   }
92506 }
92507
92508
92509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92510   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92511   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92512
92513   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92514   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92515   {
92516     try {
92517       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92518     } catch (std::out_of_range& e) {
92519       {
92520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (std::exception& e) {
92523       {
92524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92529       };
92530     }
92531   }
92532 }
92533
92534
92535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92536   unsigned int jresult ;
92537   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92538   Dali::Toolkit::Slider arg2 ;
92539   float arg3 ;
92540   Dali::Toolkit::Slider *argp2 ;
92541   bool result;
92542
92543   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92544   argp2 = (Dali::Toolkit::Slider *)jarg2;
92545   if (!argp2) {
92546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92547     return 0;
92548   }
92549   arg2 = *argp2;
92550   arg3 = (float)jarg3;
92551   {
92552     try {
92553       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92554     } catch (std::out_of_range& e) {
92555       {
92556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92557       };
92558     } catch (std::exception& e) {
92559       {
92560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92561       };
92562     } catch (...) {
92563       {
92564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92565       };
92566     }
92567   }
92568   jresult = result;
92569   return jresult;
92570 }
92571
92572
92573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92574   void * jresult ;
92575   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92576
92577   {
92578     try {
92579       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92591       };
92592     }
92593   }
92594   jresult = (void *)result;
92595   return jresult;
92596 }
92597
92598
92599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92600   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92601
92602   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92603   {
92604     try {
92605       delete arg1;
92606     } catch (std::out_of_range& e) {
92607       {
92608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92609       };
92610     } catch (std::exception& e) {
92611       {
92612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92613       };
92614     } catch (...) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92617       };
92618     }
92619   }
92620 }
92621
92622
92623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92624   unsigned int jresult ;
92625   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92626   bool result;
92627
92628   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92629   {
92630     try {
92631       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92632     } catch (std::out_of_range& e) {
92633       {
92634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92635       };
92636     } catch (std::exception& e) {
92637       {
92638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92639       };
92640     } catch (...) {
92641       {
92642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92643       };
92644     }
92645   }
92646   jresult = result;
92647   return jresult;
92648 }
92649
92650
92651 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92652   unsigned long jresult ;
92653   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92654   std::size_t result;
92655
92656   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92657   {
92658     try {
92659       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92660     } catch (std::out_of_range& e) {
92661       {
92662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92663       };
92664     } catch (std::exception& e) {
92665       {
92666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92667       };
92668     } catch (...) {
92669       {
92670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92671       };
92672     }
92673   }
92674   jresult = (unsigned long)result;
92675   return jresult;
92676 }
92677
92678
92679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92680   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92681   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92682
92683   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92684   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92685   {
92686     try {
92687       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92688     } catch (std::out_of_range& e) {
92689       {
92690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92691       };
92692     } catch (std::exception& e) {
92693       {
92694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92695       };
92696     } catch (...) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92699       };
92700     }
92701   }
92702 }
92703
92704
92705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92706   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92707   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92708
92709   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92710   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92711   {
92712     try {
92713       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92714     } catch (std::out_of_range& e) {
92715       {
92716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92717       };
92718     } catch (std::exception& e) {
92719       {
92720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92721       };
92722     } catch (...) {
92723       {
92724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92725       };
92726     }
92727   }
92728 }
92729
92730
92731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92732   unsigned int jresult ;
92733   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92734   Dali::Toolkit::Slider arg2 ;
92735   int arg3 ;
92736   Dali::Toolkit::Slider *argp2 ;
92737   bool result;
92738
92739   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92740   argp2 = (Dali::Toolkit::Slider *)jarg2;
92741   if (!argp2) {
92742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92743     return 0;
92744   }
92745   arg2 = *argp2;
92746   arg3 = (int)jarg3;
92747   {
92748     try {
92749       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92750     } catch (std::out_of_range& e) {
92751       {
92752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92753       };
92754     } catch (std::exception& e) {
92755       {
92756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92757       };
92758     } catch (...) {
92759       {
92760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92761       };
92762     }
92763   }
92764   jresult = result;
92765   return jresult;
92766 }
92767
92768
92769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92770   void * jresult ;
92771   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92772
92773   {
92774     try {
92775       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92776     } catch (std::out_of_range& e) {
92777       {
92778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92779       };
92780     } catch (std::exception& e) {
92781       {
92782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92783       };
92784     } catch (...) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92787       };
92788     }
92789   }
92790   jresult = (void *)result;
92791   return jresult;
92792 }
92793
92794
92795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92796   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92797
92798   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92799   {
92800     try {
92801       delete arg1;
92802     } catch (std::out_of_range& e) {
92803       {
92804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92805       };
92806     } catch (std::exception& e) {
92807       {
92808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92809       };
92810     } catch (...) {
92811       {
92812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92813       };
92814     }
92815   }
92816 }
92817
92818
92819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92820   void * jresult ;
92821   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92822
92823   {
92824     try {
92825       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92826     } catch (std::out_of_range& e) {
92827       {
92828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92829       };
92830     } catch (std::exception& e) {
92831       {
92832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92833       };
92834     } catch (...) {
92835       {
92836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92837       };
92838     }
92839   }
92840   jresult = (void *)result;
92841   return jresult;
92842 }
92843
92844
92845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92846   void * jresult ;
92847   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92848   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92849
92850   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92851   {
92852     try {
92853       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92854     } catch (std::out_of_range& e) {
92855       {
92856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92857       };
92858     } catch (std::exception& e) {
92859       {
92860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92861       };
92862     } catch (...) {
92863       {
92864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92865       };
92866     }
92867   }
92868   jresult = (void *)result;
92869   return jresult;
92870 }
92871
92872
92873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92874   void * jresult ;
92875   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92876   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92877
92878   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92879   if (!arg1) {
92880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92881     return 0;
92882   }
92883   {
92884     try {
92885       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92886     } catch (std::out_of_range& e) {
92887       {
92888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92889       };
92890     } catch (std::exception& e) {
92891       {
92892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92893       };
92894     } catch (...) {
92895       {
92896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92897       };
92898     }
92899   }
92900   jresult = (void *)result;
92901   return jresult;
92902 }
92903
92904
92905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92906   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92907
92908   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92909   {
92910     try {
92911       delete arg1;
92912     } catch (std::out_of_range& e) {
92913       {
92914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92915       };
92916     } catch (std::exception& e) {
92917       {
92918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92919       };
92920     } catch (...) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92923       };
92924     }
92925   }
92926 }
92927
92928
92929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92930   void * jresult ;
92931   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92932   Dali::Toolkit::Ruler *result = 0 ;
92933
92934   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92935   {
92936     try {
92937       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92938     } catch (std::out_of_range& e) {
92939       {
92940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92941       };
92942     } catch (std::exception& e) {
92943       {
92944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92945       };
92946     } catch (...) {
92947       {
92948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92949       };
92950     }
92951   }
92952   jresult = (void *)result;
92953   return jresult;
92954 }
92955
92956
92957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92958   void * jresult ;
92959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92960   Dali::Toolkit::Ruler *result = 0 ;
92961
92962   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92963   {
92964     try {
92965       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92973       };
92974     } catch (...) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92977       };
92978     }
92979   }
92980   jresult = (void *)result;
92981   return jresult;
92982 }
92983
92984
92985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92986   void * jresult ;
92987   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92988   Dali::Toolkit::Ruler *result = 0 ;
92989
92990   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92991   {
92992     try {
92993       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92994     } catch (std::out_of_range& e) {
92995       {
92996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92997       };
92998     } catch (std::exception& e) {
92999       {
93000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93001       };
93002     } catch (...) {
93003       {
93004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93005       };
93006     }
93007   }
93008   jresult = (void *)result;
93009   return jresult;
93010 }
93011
93012
93013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93014   void * jresult ;
93015   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93016   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93018
93019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93020   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93021   if (!arg2) {
93022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93023     return 0;
93024   }
93025   {
93026     try {
93027       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93028     } catch (std::out_of_range& e) {
93029       {
93030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93031       };
93032     } catch (std::exception& e) {
93033       {
93034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93035       };
93036     } catch (...) {
93037       {
93038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93039       };
93040     }
93041   }
93042   jresult = (void *)result;
93043   return jresult;
93044 }
93045
93046
93047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93048   void * jresult ;
93049   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93050   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93051   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93052
93053   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93054   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93055   {
93056     try {
93057       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93058     } catch (std::out_of_range& e) {
93059       {
93060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93061       };
93062     } catch (std::exception& e) {
93063       {
93064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93065       };
93066     } catch (...) {
93067       {
93068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93069       };
93070     }
93071   }
93072   jresult = (void *)result;
93073   return jresult;
93074 }
93075
93076
93077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93078   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93079
93080   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93081   {
93082     try {
93083       (arg1)->Reset();
93084     } catch (std::out_of_range& e) {
93085       {
93086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93087       };
93088     } catch (std::exception& e) {
93089       {
93090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93095       };
93096     }
93097   }
93098 }
93099
93100
93101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93102   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93103   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93104
93105   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93106   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93107   {
93108     try {
93109       (arg1)->Reset(arg2);
93110     } catch (std::out_of_range& e) {
93111       {
93112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93113       };
93114     } catch (std::exception& e) {
93115       {
93116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93117       };
93118     } catch (...) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93121       };
93122     }
93123   }
93124 }
93125
93126
93127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93128   void * jresult ;
93129   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93130   Dali::Toolkit::Ruler *result = 0 ;
93131
93132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93133   {
93134     try {
93135       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93136     } catch (std::out_of_range& e) {
93137       {
93138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93139       };
93140     } catch (std::exception& e) {
93141       {
93142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93143       };
93144     } catch (...) {
93145       {
93146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93147       };
93148     }
93149   }
93150   jresult = (void *)result;
93151   return jresult;
93152 }
93153
93154
93155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93156   float jresult ;
93157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93158   float arg2 ;
93159   float arg3 ;
93160   float result;
93161
93162   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93163   arg2 = (float)jarg2;
93164   arg3 = (float)jarg3;
93165   {
93166     try {
93167       result = (float)(*arg1)->Snap(arg2,arg3);
93168     } catch (std::out_of_range& e) {
93169       {
93170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93171       };
93172     } catch (std::exception& e) {
93173       {
93174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93175       };
93176     } catch (...) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93179       };
93180     }
93181   }
93182   jresult = result;
93183   return jresult;
93184 }
93185
93186
93187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93188   float jresult ;
93189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93190   float arg2 ;
93191   float result;
93192
93193   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93194   arg2 = (float)jarg2;
93195   {
93196     try {
93197       result = (float)(*arg1)->Snap(arg2);
93198     } catch (std::out_of_range& e) {
93199       {
93200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93201       };
93202     } catch (std::exception& e) {
93203       {
93204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93205       };
93206     } catch (...) {
93207       {
93208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93209       };
93210     }
93211   }
93212   jresult = result;
93213   return jresult;
93214 }
93215
93216
93217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93218   float jresult ;
93219   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93220   unsigned int arg2 ;
93221   unsigned int *arg3 = 0 ;
93222   bool arg4 ;
93223   float result;
93224
93225   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93226   arg2 = (unsigned int)jarg2;
93227   arg3 = (unsigned int *)jarg3;
93228   arg4 = jarg4 ? true : false;
93229   {
93230     try {
93231       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93239       };
93240     } catch (...) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93243       };
93244     }
93245   }
93246   jresult = result;
93247   return jresult;
93248 }
93249
93250
93251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93252   unsigned int jresult ;
93253   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93254   float arg2 ;
93255   bool arg3 ;
93256   unsigned int result;
93257
93258   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93259   arg2 = (float)jarg2;
93260   arg3 = jarg3 ? true : false;
93261   {
93262     try {
93263       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93264     } catch (std::out_of_range& e) {
93265       {
93266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93267       };
93268     } catch (std::exception& e) {
93269       {
93270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93271       };
93272     } catch (...) {
93273       {
93274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93275       };
93276     }
93277   }
93278   jresult = result;
93279   return jresult;
93280 }
93281
93282
93283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93284   unsigned int jresult ;
93285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93286   unsigned int result;
93287
93288   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93289   {
93290     try {
93291       result = (unsigned int)(*arg1)->GetTotalPages();
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93299       };
93300     } catch (...) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93303       };
93304     }
93305   }
93306   jresult = result;
93307   return jresult;
93308 }
93309
93310
93311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93312   int jresult ;
93313   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93314   Dali::Toolkit::Ruler::RulerType result;
93315
93316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93317   {
93318     try {
93319       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (...) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93331       };
93332     }
93333   }
93334   jresult = (int)result;
93335   return jresult;
93336 }
93337
93338
93339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93340   unsigned int jresult ;
93341   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93342   bool result;
93343
93344   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93345   {
93346     try {
93347       result = (bool)(*arg1)->IsEnabled();
93348     } catch (std::out_of_range& e) {
93349       {
93350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93351       };
93352     } catch (std::exception& e) {
93353       {
93354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93355       };
93356     } catch (...) {
93357       {
93358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93359       };
93360     }
93361   }
93362   jresult = result;
93363   return jresult;
93364 }
93365
93366
93367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93368   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93369
93370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93371   {
93372     try {
93373       (*arg1)->Enable();
93374     } catch (std::out_of_range& e) {
93375       {
93376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93377       };
93378     } catch (std::exception& e) {
93379       {
93380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93381       };
93382     } catch (...) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93385       };
93386     }
93387   }
93388 }
93389
93390
93391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93393
93394   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93395   {
93396     try {
93397       (*arg1)->Disable();
93398     } catch (std::out_of_range& e) {
93399       {
93400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93401       };
93402     } catch (std::exception& e) {
93403       {
93404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93405       };
93406     } catch (...) {
93407       {
93408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93409       };
93410     }
93411   }
93412 }
93413
93414
93415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93417   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93418   Dali::Toolkit::RulerDomain *argp2 ;
93419
93420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93421   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93422   if (!argp2) {
93423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93424     return ;
93425   }
93426   arg2 = *argp2;
93427   {
93428     try {
93429       (*arg1)->SetDomain(arg2);
93430     } catch (std::out_of_range& e) {
93431       {
93432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93433       };
93434     } catch (std::exception& e) {
93435       {
93436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93437       };
93438     } catch (...) {
93439       {
93440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93441       };
93442     }
93443   }
93444 }
93445
93446
93447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93448   void * jresult ;
93449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93450   Dali::Toolkit::RulerDomain *result = 0 ;
93451
93452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93453   {
93454     try {
93455       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (...) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93467       };
93468     }
93469   }
93470   jresult = (void *)result;
93471   return jresult;
93472 }
93473
93474
93475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93476   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93477
93478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93479   {
93480     try {
93481       (*arg1)->DisableDomain();
93482     } catch (std::out_of_range& e) {
93483       {
93484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93485       };
93486     } catch (std::exception& e) {
93487       {
93488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93489       };
93490     } catch (...) {
93491       {
93492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93493       };
93494     }
93495   }
93496 }
93497
93498
93499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93500   float jresult ;
93501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93502   float arg2 ;
93503   float arg3 ;
93504   float arg4 ;
93505   float result;
93506
93507   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93508   arg2 = (float)jarg2;
93509   arg3 = (float)jarg3;
93510   arg4 = (float)jarg4;
93511   {
93512     try {
93513       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93514     } catch (std::out_of_range& e) {
93515       {
93516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93517       };
93518     } catch (std::exception& e) {
93519       {
93520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93521       };
93522     } catch (...) {
93523       {
93524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93525       };
93526     }
93527   }
93528   jresult = result;
93529   return jresult;
93530 }
93531
93532
93533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93534   float jresult ;
93535   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93536   float arg2 ;
93537   float arg3 ;
93538   float result;
93539
93540   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93541   arg2 = (float)jarg2;
93542   arg3 = (float)jarg3;
93543   {
93544     try {
93545       result = (float)(*arg1)->Clamp(arg2,arg3);
93546     } catch (std::out_of_range& e) {
93547       {
93548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93549       };
93550     } catch (std::exception& e) {
93551       {
93552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93553       };
93554     } catch (...) {
93555       {
93556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93557       };
93558     }
93559   }
93560   jresult = result;
93561   return jresult;
93562 }
93563
93564
93565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93566   float jresult ;
93567   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93568   float arg2 ;
93569   float result;
93570
93571   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93572   arg2 = (float)jarg2;
93573   {
93574     try {
93575       result = (float)(*arg1)->Clamp(arg2);
93576     } catch (std::out_of_range& e) {
93577       {
93578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93579       };
93580     } catch (std::exception& e) {
93581       {
93582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93583       };
93584     } catch (...) {
93585       {
93586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93587       };
93588     }
93589   }
93590   jresult = result;
93591   return jresult;
93592 }
93593
93594
93595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93596   float jresult ;
93597   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93598   float arg2 ;
93599   float arg3 ;
93600   float arg4 ;
93601   Dali::Toolkit::ClampState *arg5 = 0 ;
93602   float result;
93603
93604   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93605   arg2 = (float)jarg2;
93606   arg3 = (float)jarg3;
93607   arg4 = (float)jarg4;
93608   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93609   if (!arg5) {
93610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93611     return 0;
93612   }
93613   {
93614     try {
93615       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93616     } catch (std::out_of_range& e) {
93617       {
93618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93619       };
93620     } catch (std::exception& e) {
93621       {
93622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (...) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93627       };
93628     }
93629   }
93630   jresult = result;
93631   return jresult;
93632 }
93633
93634
93635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93636   float jresult ;
93637   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93638   float arg2 ;
93639   float arg3 ;
93640   float arg4 ;
93641   float arg5 ;
93642   float result;
93643
93644   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93645   arg2 = (float)jarg2;
93646   arg3 = (float)jarg3;
93647   arg4 = (float)jarg4;
93648   arg5 = (float)jarg5;
93649   {
93650     try {
93651       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93652     } catch (std::out_of_range& e) {
93653       {
93654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93655       };
93656     } catch (std::exception& e) {
93657       {
93658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93659       };
93660     } catch (...) {
93661       {
93662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93663       };
93664     }
93665   }
93666   jresult = result;
93667   return jresult;
93668 }
93669
93670
93671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93672   float jresult ;
93673   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93674   float arg2 ;
93675   float arg3 ;
93676   float arg4 ;
93677   float result;
93678
93679   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93680   arg2 = (float)jarg2;
93681   arg3 = (float)jarg3;
93682   arg4 = (float)jarg4;
93683   {
93684     try {
93685       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93686     } catch (std::out_of_range& e) {
93687       {
93688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93689       };
93690     } catch (std::exception& e) {
93691       {
93692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93693       };
93694     } catch (...) {
93695       {
93696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93697       };
93698     }
93699   }
93700   jresult = result;
93701   return jresult;
93702 }
93703
93704
93705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93706   float jresult ;
93707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93708   float arg2 ;
93709   float arg3 ;
93710   float result;
93711
93712   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93713   arg2 = (float)jarg2;
93714   arg3 = (float)jarg3;
93715   {
93716     try {
93717       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93718     } catch (std::out_of_range& e) {
93719       {
93720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93721       };
93722     } catch (std::exception& e) {
93723       {
93724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93725       };
93726     } catch (...) {
93727       {
93728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93729       };
93730     }
93731   }
93732   jresult = result;
93733   return jresult;
93734 }
93735
93736
93737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93738   float jresult ;
93739   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93740   float arg2 ;
93741   float result;
93742
93743   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93744   arg2 = (float)jarg2;
93745   {
93746     try {
93747       result = (float)(*arg1)->SnapAndClamp(arg2);
93748     } catch (std::out_of_range& e) {
93749       {
93750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93751       };
93752     } catch (std::exception& e) {
93753       {
93754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93755       };
93756     } catch (...) {
93757       {
93758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93759       };
93760     }
93761   }
93762   jresult = result;
93763   return jresult;
93764 }
93765
93766
93767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93768   float jresult ;
93769   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93770   float arg2 ;
93771   float arg3 ;
93772   float arg4 ;
93773   float arg5 ;
93774   Dali::Toolkit::ClampState *arg6 = 0 ;
93775   float result;
93776
93777   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93778   arg2 = (float)jarg2;
93779   arg3 = (float)jarg3;
93780   arg4 = (float)jarg4;
93781   arg5 = (float)jarg5;
93782   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93783   if (!arg6) {
93784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93785     return 0;
93786   }
93787   {
93788     try {
93789       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93790     } catch (std::out_of_range& e) {
93791       {
93792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93793       };
93794     } catch (std::exception& e) {
93795       {
93796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93797       };
93798     } catch (...) {
93799       {
93800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93801       };
93802     }
93803   }
93804   jresult = result;
93805   return jresult;
93806 }
93807
93808
93809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93810   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93811
93812   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93813   {
93814     try {
93815       (*arg1)->Reference();
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 (...) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93827       };
93828     }
93829   }
93830 }
93831
93832
93833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93834   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93835
93836   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93837   {
93838     try {
93839       (*arg1)->Unreference();
93840     } catch (std::out_of_range& e) {
93841       {
93842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93843       };
93844     } catch (std::exception& e) {
93845       {
93846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93847       };
93848     } catch (...) {
93849       {
93850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93851       };
93852     }
93853   }
93854 }
93855
93856
93857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93858   int jresult ;
93859   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93860   int result;
93861
93862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93863   {
93864     try {
93865       result = (int)(*arg1)->ReferenceCount();
93866     } catch (std::out_of_range& e) {
93867       {
93868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93869       };
93870     } catch (std::exception& e) {
93871       {
93872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93873       };
93874     } catch (...) {
93875       {
93876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93877       };
93878     }
93879   }
93880   jresult = result;
93881   return jresult;
93882 }
93883
93884
93885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
93886   unsigned int jresult ;
93887   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93888   bool result;
93889
93890   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93891   {
93892     try {
93893       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93894     } catch (std::out_of_range& e) {
93895       {
93896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93897       };
93898     } catch (std::exception& e) {
93899       {
93900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93901       };
93902     } catch (...) {
93903       {
93904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93905       };
93906     }
93907   }
93908   jresult = result;
93909   return jresult;
93910 }
93911
93912
93913 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
93914   unsigned long jresult ;
93915   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93916   std::size_t result;
93917
93918   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93919   {
93920     try {
93921       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
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 (...) {
93931       {
93932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93933       };
93934     }
93935   }
93936   jresult = (unsigned long)result;
93937   return jresult;
93938 }
93939
93940
93941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
93942   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93943   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93944
93945   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93946   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93947   {
93948     try {
93949       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93950     } catch (std::out_of_range& e) {
93951       {
93952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93953       };
93954     } catch (std::exception& e) {
93955       {
93956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93957       };
93958     } catch (...) {
93959       {
93960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93961       };
93962     }
93963   }
93964 }
93965
93966
93967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
93968   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93969   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93970
93971   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93972   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93973   {
93974     try {
93975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93976     } catch (std::out_of_range& e) {
93977       {
93978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93979       };
93980     } catch (std::exception& e) {
93981       {
93982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93983       };
93984     } catch (...) {
93985       {
93986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93987       };
93988     }
93989   }
93990 }
93991
93992
93993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
93994   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93995   Dali::Toolkit::Control arg2 ;
93996   Dali::Toolkit::Control *argp2 ;
93997
93998   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93999   argp2 = (Dali::Toolkit::Control *)jarg2;
94000   if (!argp2) {
94001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94002     return ;
94003   }
94004   arg2 = *argp2;
94005   {
94006     try {
94007       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94008     } catch (std::out_of_range& e) {
94009       {
94010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94011       };
94012     } catch (std::exception& e) {
94013       {
94014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94015       };
94016     } catch (...) {
94017       {
94018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94019       };
94020     }
94021   }
94022 }
94023
94024
94025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94026   void * jresult ;
94027   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94028
94029   {
94030     try {
94031       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94032     } catch (std::out_of_range& e) {
94033       {
94034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94035       };
94036     } catch (std::exception& e) {
94037       {
94038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94039       };
94040     } catch (...) {
94041       {
94042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94043       };
94044     }
94045   }
94046   jresult = (void *)result;
94047   return jresult;
94048 }
94049
94050
94051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94052   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94053
94054   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94055   {
94056     try {
94057       delete arg1;
94058     } catch (std::out_of_range& e) {
94059       {
94060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94061       };
94062     } catch (std::exception& e) {
94063       {
94064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94065       };
94066     } catch (...) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94069       };
94070     }
94071   }
94072 }
94073
94074 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94075     return (Dali::RefObject *)jarg1;
94076 }
94077
94078 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94079     return (Dali::SignalObserver *)jarg1;
94080 }
94081
94082 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94083     return (Dali::ConnectionTrackerInterface *)jarg1;
94084 }
94085
94086 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94087     return (Dali::BaseHandle *)jarg1;
94088 }
94089
94090 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94091     return (Dali::BaseHandle *)jarg1;
94092 }
94093
94094 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94095     return (Dali::BaseHandle *)jarg1;
94096 }
94097
94098 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94099     return (Dali::BaseHandle *)jarg1;
94100 }
94101
94102 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94103     return (Dali::BaseHandle *)jarg1;
94104 }
94105
94106 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94107     return (Dali::BaseHandle *)jarg1;
94108 }
94109
94110 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94111     return (Dali::BaseHandle *)jarg1;
94112 }
94113
94114 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94115     return (Dali::BaseHandle *)jarg1;
94116 }
94117
94118 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94119     return (Dali::BaseHandle *)jarg1;
94120 }
94121
94122 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94123     return (Dali::BaseHandle *)jarg1;
94124 }
94125
94126 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94127     return (Dali::BaseHandle *)jarg1;
94128 }
94129
94130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94131     return (Dali::BaseHandle *)jarg1;
94132 }
94133
94134 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94135     return (Dali::BaseHandle *)jarg1;
94136 }
94137
94138 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94139     return (Dali::Handle *)jarg1;
94140 }
94141
94142 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94143     return (Dali::Handle *)jarg1;
94144 }
94145
94146 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94147     return (Dali::BaseHandle *)jarg1;
94148 }
94149
94150 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94151     return (Dali::BaseHandle *)jarg1;
94152 }
94153
94154 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94155     return (Dali::Handle *)jarg1;
94156 }
94157
94158 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94159     return (Dali::BaseHandle *)jarg1;
94160 }
94161
94162 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94163     return (Dali::Handle *)jarg1;
94164 }
94165
94166 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94167     return (Dali::GestureDetector *)jarg1;
94168 }
94169
94170 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94171     return (Dali::Gesture *)jarg1;
94172 }
94173
94174 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94175     return (Dali::Handle *)jarg1;
94176 }
94177
94178 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94179     return (Dali::Actor *)jarg1;
94180 }
94181
94182 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94183     return (Dali::BaseHandle *)jarg1;
94184 }
94185
94186 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94187     return (Dali::RefObject *)jarg1;
94188 }
94189
94190 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94191     return (Dali::Actor *)jarg1;
94192 }
94193
94194 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94195     return (Dali::GestureDetector *)jarg1;
94196 }
94197
94198 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94199     return (Dali::Gesture *)jarg1;
94200 }
94201
94202 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94203     return (Dali::GestureDetector *)jarg1;
94204 }
94205
94206 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94207     return (Dali::Gesture *)jarg1;
94208 }
94209
94210 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94211     return (Dali::GestureDetector *)jarg1;
94212 }
94213
94214 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94215     return (Dali::Gesture *)jarg1;
94216 }
94217
94218 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94219     return (Dali::BaseHandle *)jarg1;
94220 }
94221
94222 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94223     return (Dali::Handle *)jarg1;
94224 }
94225
94226 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94227     return (Dali::BaseHandle *)jarg1;
94228 }
94229
94230 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94231     return (Dali::Handle *)jarg1;
94232 }
94233
94234 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94235     return (Dali::Handle *)jarg1;
94236 }
94237
94238 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94239     return (Dali::Image *)jarg1;
94240 }
94241
94242 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94243     return (Dali::Image *)jarg1;
94244 }
94245
94246 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94247     return (Dali::Image *)jarg1;
94248 }
94249
94250 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94251     return (Dali::RefObject *)jarg1;
94252 }
94253
94254 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94255     return (Dali::Image *)jarg1;
94256 }
94257
94258 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94259     return (Dali::Image *)jarg1;
94260 }
94261
94262 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94263     return (Dali::ResourceImage *)jarg1;
94264 }
94265
94266 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94267     return (Dali::Actor *)jarg1;
94268 }
94269
94270 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94271     return (Dali::BaseHandle *)jarg1;
94272 }
94273
94274 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94275     return (Dali::BaseHandle *)jarg1;
94276 }
94277
94278 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94279     return (Dali::BaseHandle *)jarg1;
94280 }
94281
94282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94283     return (Dali::BaseHandle *)jarg1;
94284 }
94285
94286 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94287     return (Dali::BaseHandle *)jarg1;
94288 }
94289
94290 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94291     return (Dali::BaseHandle *)jarg1;
94292 }
94293
94294 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94295     return (Dali::CustomActorImpl *)jarg1;
94296 }
94297
94298 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94299     return (Dali::CustomActor *)jarg1;
94300 }
94301
94302 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94303     return (Dali::BaseHandle *)jarg1;
94304 }
94305
94306 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94307     return (Dali::Toolkit::Control *)jarg1;
94308 }
94309
94310 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94311     return (Dali::Toolkit::Control *)jarg1;
94312 }
94313
94314 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94315     return (Dali::Toolkit::Button *)jarg1;
94316 }
94317
94318 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94319     return (Dali::Toolkit::Button *)jarg1;
94320 }
94321
94322 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94323     return (Dali::Toolkit::Button *)jarg1;
94324 }
94325
94326 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94327     return (Dali::Toolkit::Control *)jarg1;
94328 }
94329
94330 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94331     return (Dali::Toolkit::Control *)jarg1;
94332 }
94333
94334 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94335     return (Dali::Toolkit::Control *)jarg1;
94336 }
94337
94338 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94339     return (Dali::Toolkit::Control *)jarg1;
94340 }
94341
94342 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94343     return (Dali::Toolkit::Control *)jarg1;
94344 }
94345
94346 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94347     return (Dali::RefObject *)jarg1;
94348 }
94349
94350 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94351     return (Dali::Toolkit::Scrollable *)jarg1;
94352 }
94353
94354 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94355     return (Dali::BaseHandle *)jarg1;
94356 }
94357
94358 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94359     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94360 }
94361
94362 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94363     return (Dali::RefObject *)jarg1;
94364 }
94365
94366 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94367     return (Dali::Toolkit::Ruler *)jarg1;
94368 }
94369
94370 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94371     return (Dali::Toolkit::Ruler *)jarg1;
94372 }
94373
94374 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94375     return (Dali::Toolkit::Scrollable *)jarg1;
94376 }
94377
94378 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94379     return (Dali::Toolkit::Control *)jarg1;
94380 }
94381
94382 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94383     return (Dali::Toolkit::Control *)jarg1;
94384 }
94385
94386 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94387     return (Dali::Toolkit::Control *)jarg1;
94388 }
94389
94390 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94391     return (Dali::Toolkit::Control *)jarg1;
94392 }
94393
94394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94395     return (Dali::BaseHandle *)jarg1;
94396 }
94397
94398 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94399     return (Dali::BaseHandle *)jarg1;
94400 }
94401
94402 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94403     return (Dali::Toolkit::Control *)jarg1;
94404 }
94405
94406 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94407     return (Dali::Toolkit::Control *)jarg1;
94408 }
94409
94410 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94411     return (Dali::Toolkit::Control *)jarg1;
94412 }
94413
94414 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94415     return (Dali::Toolkit::Control *)jarg1;
94416 }
94417
94418 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94419     return (Dali::Toolkit::Control *)jarg1;
94420 }
94421
94422 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94423     return (Dali::Toolkit::Control *)jarg1;
94424 }
94425
94426 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94427     return (Dali::Toolkit::PageTurnView *)jarg1;
94428 }
94429
94430 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94431     return (Dali::Toolkit::PageTurnView *)jarg1;
94432 }
94433
94434 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94435     return (Dali::Toolkit::Button *)jarg1;
94436 }
94437
94438 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94439     return (Dali::BaseHandle *)jarg1;
94440 }
94441
94442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94443     return (Dali::BaseHandle *)jarg1;
94444 }
94445
94446 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94447     return (Dali::BaseHandle *)jarg1;
94448 }
94449
94450
94451
94452
94453
94454 //////////////////////////////////////////////////
94455 //from dali-swig autogeneration (from dali_wrap.cpp)
94456
94457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94458   void * jresult ;
94459   Dali::ImfManager::ImfEventData *result = 0 ;
94460
94461   {
94462     try {
94463       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94464     } catch (std::out_of_range& e) {
94465       {
94466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94467       };
94468     } catch (std::exception& e) {
94469       {
94470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94471       };
94472     } catch (...) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94475       };
94476     }
94477   }
94478   jresult = (void *)result;
94479   return jresult;
94480 }
94481
94482
94483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94484   void * jresult ;
94485   Dali::ImfManager::ImfEvent arg1 ;
94486   std::string *arg2 = 0 ;
94487   int arg3 ;
94488   int arg4 ;
94489   Dali::ImfManager::ImfEventData *result = 0 ;
94490
94491   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94492   if (!jarg2) {
94493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94494     return 0;
94495   }
94496   std::string arg2_str(jarg2);
94497   arg2 = &arg2_str;
94498   arg3 = (int)jarg3;
94499   arg4 = (int)jarg4;
94500   {
94501     try {
94502       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94503     } catch (std::out_of_range& e) {
94504       {
94505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94506       };
94507     } catch (std::exception& e) {
94508       {
94509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94510       };
94511     } catch (...) {
94512       {
94513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94514       };
94515     }
94516   }
94517   jresult = (void *)result;
94518
94519   //argout typemap for const std::string&
94520
94521   return jresult;
94522 }
94523
94524
94525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94526   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94527   std::string *arg2 = 0 ;
94528
94529   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94530   if (!jarg2) {
94531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94532     return ;
94533   }
94534   std::string arg2_str(jarg2);
94535   arg2 = &arg2_str;
94536   if (arg1) (arg1)->predictiveString = *arg2;
94537
94538   //argout typemap for const std::string&
94539
94540 }
94541
94542
94543 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94544   char * jresult ;
94545   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94546   std::string *result = 0 ;
94547
94548   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94549   result = (std::string *) & ((arg1)->predictiveString);
94550   jresult = SWIG_csharp_string_callback(result->c_str());
94551   return jresult;
94552 }
94553
94554
94555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94556   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94557   Dali::ImfManager::ImfEvent arg2 ;
94558
94559   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94560   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94561   if (arg1) (arg1)->eventName = arg2;
94562 }
94563
94564
94565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94566   int jresult ;
94567   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94568   Dali::ImfManager::ImfEvent result;
94569
94570   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94571   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94572   jresult = (int)result;
94573   return jresult;
94574 }
94575
94576
94577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94578   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94579   int arg2 ;
94580
94581   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94582   arg2 = (int)jarg2;
94583   if (arg1) (arg1)->cursorOffset = arg2;
94584 }
94585
94586
94587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94588   int jresult ;
94589   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94590   int result;
94591
94592   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94593   result = (int) ((arg1)->cursorOffset);
94594   jresult = result;
94595   return jresult;
94596 }
94597
94598
94599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94600   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94601   int arg2 ;
94602
94603   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94604   arg2 = (int)jarg2;
94605   if (arg1) (arg1)->numberOfChars = arg2;
94606 }
94607
94608
94609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94610   int jresult ;
94611   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94612   int result;
94613
94614   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94615   result = (int) ((arg1)->numberOfChars);
94616   jresult = result;
94617   return jresult;
94618 }
94619
94620
94621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94622   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94623
94624   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94625   {
94626     try {
94627       delete arg1;
94628     } catch (std::out_of_range& e) {
94629       {
94630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94631       };
94632     } catch (std::exception& e) {
94633       {
94634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94635       };
94636     } catch (...) {
94637       {
94638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94639       };
94640     }
94641   }
94642 }
94643
94644
94645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94646   void * jresult ;
94647   Dali::ImfManager::ImfCallbackData *result = 0 ;
94648
94649   {
94650     try {
94651       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94652     } catch (std::out_of_range& e) {
94653       {
94654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94655       };
94656     } catch (std::exception& e) {
94657       {
94658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94659       };
94660     } catch (...) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94663       };
94664     }
94665   }
94666   jresult = (void *)result;
94667   return jresult;
94668 }
94669
94670
94671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94672   void * jresult ;
94673   bool arg1 ;
94674   int arg2 ;
94675   std::string *arg3 = 0 ;
94676   bool arg4 ;
94677   Dali::ImfManager::ImfCallbackData *result = 0 ;
94678
94679   arg1 = jarg1 ? true : false;
94680   arg2 = (int)jarg2;
94681   if (!jarg3) {
94682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94683     return 0;
94684   }
94685   std::string arg3_str(jarg3);
94686   arg3 = &arg3_str;
94687   arg4 = jarg4 ? true : false;
94688   {
94689     try {
94690       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94691     } catch (std::out_of_range& e) {
94692       {
94693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94694       };
94695     } catch (std::exception& e) {
94696       {
94697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94698       };
94699     } catch (...) {
94700       {
94701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94702       };
94703     }
94704   }
94705   jresult = (void *)result;
94706
94707   //argout typemap for const std::string&
94708
94709   return jresult;
94710 }
94711
94712
94713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94714   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94715   std::string *arg2 = 0 ;
94716
94717   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94718   if (!jarg2) {
94719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94720     return ;
94721   }
94722   std::string arg2_str(jarg2);
94723   arg2 = &arg2_str;
94724   if (arg1) (arg1)->currentText = *arg2;
94725
94726   //argout typemap for const std::string&
94727
94728 }
94729
94730
94731 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94732   char * jresult ;
94733   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94734   std::string *result = 0 ;
94735
94736   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94737   result = (std::string *) & ((arg1)->currentText);
94738   jresult = SWIG_csharp_string_callback(result->c_str());
94739   return jresult;
94740 }
94741
94742
94743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94744   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94745   int arg2 ;
94746
94747   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94748   arg2 = (int)jarg2;
94749   if (arg1) (arg1)->cursorPosition = arg2;
94750 }
94751
94752
94753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94754   int jresult ;
94755   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94756   int result;
94757
94758   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94759   result = (int) ((arg1)->cursorPosition);
94760   jresult = result;
94761   return jresult;
94762 }
94763
94764
94765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94766   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94767   bool arg2 ;
94768
94769   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94770   arg2 = jarg2 ? true : false;
94771   if (arg1) (arg1)->update = arg2;
94772 }
94773
94774
94775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94776   unsigned int jresult ;
94777   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94778   bool result;
94779
94780   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94781   result = (bool) ((arg1)->update);
94782   jresult = result;
94783   return jresult;
94784 }
94785
94786
94787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94788   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94789   bool arg2 ;
94790
94791   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94792   arg2 = jarg2 ? true : false;
94793   if (arg1) (arg1)->preeditResetRequired = arg2;
94794 }
94795
94796
94797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94798   unsigned int jresult ;
94799   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94800   bool result;
94801
94802   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94803   result = (bool) ((arg1)->preeditResetRequired);
94804   jresult = result;
94805   return jresult;
94806 }
94807
94808
94809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94810   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94811
94812   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94813   {
94814     try {
94815       delete arg1;
94816     } catch (std::out_of_range& e) {
94817       {
94818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94819       };
94820     } catch (std::exception& e) {
94821       {
94822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94823       };
94824     } catch (...) {
94825       {
94826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94827       };
94828     }
94829   }
94830 }
94831
94832
94833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94834   void * jresult ;
94835   Dali::ImfManager result;
94836
94837   {
94838     try {
94839       result = Dali::ImfManager::Get();
94840     } catch (std::out_of_range& e) {
94841       {
94842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94843       };
94844     } catch (std::exception& e) {
94845       {
94846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94847       };
94848     } catch (...) {
94849       {
94850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94851       };
94852     }
94853   }
94854   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94855   return jresult;
94856 }
94857
94858
94859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94860   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94861
94862   arg1 = (Dali::ImfManager *)jarg1;
94863   {
94864     try {
94865       (arg1)->Activate();
94866     } catch (std::out_of_range& e) {
94867       {
94868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94869       };
94870     } catch (std::exception& e) {
94871       {
94872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94873       };
94874     } catch (...) {
94875       {
94876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94877       };
94878     }
94879   }
94880 }
94881
94882
94883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
94884   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94885
94886   arg1 = (Dali::ImfManager *)jarg1;
94887   {
94888     try {
94889       (arg1)->Deactivate();
94890     } catch (std::out_of_range& e) {
94891       {
94892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94893       };
94894     } catch (std::exception& e) {
94895       {
94896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94897       };
94898     } catch (...) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94901       };
94902     }
94903   }
94904 }
94905
94906
94907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
94908   unsigned int jresult ;
94909   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94910   bool result;
94911
94912   arg1 = (Dali::ImfManager *)jarg1;
94913   {
94914     try {
94915       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
94916     } catch (std::out_of_range& e) {
94917       {
94918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94919       };
94920     } catch (std::exception& e) {
94921       {
94922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94923       };
94924     } catch (...) {
94925       {
94926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94927       };
94928     }
94929   }
94930   jresult = result;
94931   return jresult;
94932 }
94933
94934
94935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
94936   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94937   bool arg2 ;
94938
94939   arg1 = (Dali::ImfManager *)jarg1;
94940   arg2 = jarg2 ? true : false;
94941   {
94942     try {
94943       (arg1)->SetRestoreAfterFocusLost(arg2);
94944     } catch (std::out_of_range& e) {
94945       {
94946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94947       };
94948     } catch (std::exception& e) {
94949       {
94950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94951       };
94952     } catch (...) {
94953       {
94954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94955       };
94956     }
94957   }
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
94962   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94963
94964   arg1 = (Dali::ImfManager *)jarg1;
94965   {
94966     try {
94967       (arg1)->Reset();
94968     } catch (std::out_of_range& e) {
94969       {
94970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94971       };
94972     } catch (std::exception& e) {
94973       {
94974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94975       };
94976     } catch (...) {
94977       {
94978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94979       };
94980     }
94981   }
94982 }
94983
94984
94985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
94986   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94987
94988   arg1 = (Dali::ImfManager *)jarg1;
94989   {
94990     try {
94991       (arg1)->NotifyCursorPosition();
94992     } catch (std::out_of_range& e) {
94993       {
94994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94995       };
94996     } catch (std::exception& e) {
94997       {
94998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94999       };
95000     } catch (...) {
95001       {
95002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95003       };
95004     }
95005   }
95006 }
95007
95008
95009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95010   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95011   unsigned int arg2 ;
95012
95013   arg1 = (Dali::ImfManager *)jarg1;
95014   arg2 = (unsigned int)jarg2;
95015   {
95016     try {
95017       (arg1)->SetCursorPosition(arg2);
95018     } catch (std::out_of_range& e) {
95019       {
95020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95021       };
95022     } catch (std::exception& e) {
95023       {
95024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95025       };
95026     } catch (...) {
95027       {
95028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95029       };
95030     }
95031   }
95032 }
95033
95034
95035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95036   unsigned int jresult ;
95037   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95038   unsigned int result;
95039
95040   arg1 = (Dali::ImfManager *)jarg1;
95041   {
95042     try {
95043       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95044     } catch (std::out_of_range& e) {
95045       {
95046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95047       };
95048     } catch (std::exception& e) {
95049       {
95050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95051       };
95052     } catch (...) {
95053       {
95054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95055       };
95056     }
95057   }
95058   jresult = result;
95059   return jresult;
95060 }
95061
95062
95063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95064   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95065   std::string *arg2 = 0 ;
95066
95067   arg1 = (Dali::ImfManager *)jarg1;
95068   if (!jarg2) {
95069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95070     return ;
95071   }
95072   std::string arg2_str(jarg2);
95073   arg2 = &arg2_str;
95074   {
95075     try {
95076       (arg1)->SetSurroundingText((std::string const &)*arg2);
95077     } catch (std::out_of_range& e) {
95078       {
95079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95080       };
95081     } catch (std::exception& e) {
95082       {
95083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95084       };
95085     } catch (...) {
95086       {
95087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95088       };
95089     }
95090   }
95091
95092   //argout typemap for const std::string&
95093
95094 }
95095
95096
95097 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95098   char * jresult ;
95099   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95100   std::string *result = 0 ;
95101
95102   arg1 = (Dali::ImfManager *)jarg1;
95103   {
95104     try {
95105       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95106     } catch (std::out_of_range& e) {
95107       {
95108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95109       };
95110     } catch (std::exception& e) {
95111       {
95112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95113       };
95114     } catch (...) {
95115       {
95116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95117       };
95118     }
95119   }
95120   jresult = SWIG_csharp_string_callback(result->c_str());
95121   return jresult;
95122 }
95123
95124
95125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95126   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95127   bool arg2 ;
95128
95129   arg1 = (Dali::ImfManager *)jarg1;
95130   arg2 = jarg2 ? true : false;
95131   {
95132     try {
95133       (arg1)->NotifyTextInputMultiLine(arg2);
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95141       };
95142     } catch (...) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95145       };
95146     }
95147   }
95148 }
95149
95150
95151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95152   int jresult ;
95153   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95154   Dali::ImfManager::TextDirection result;
95155
95156   arg1 = (Dali::ImfManager *)jarg1;
95157   {
95158     try {
95159       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95160     } catch (std::out_of_range& e) {
95161       {
95162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95163       };
95164     } catch (std::exception& e) {
95165       {
95166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95167       };
95168     } catch (...) {
95169       {
95170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95171       };
95172     }
95173   }
95174   jresult = (int)result;
95175   return jresult;
95176 }
95177
95178
95179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95180   void * jresult ;
95181   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95182   Dali::Rect< int > result;
95183
95184   arg1 = (Dali::ImfManager *)jarg1;
95185   {
95186     try {
95187       result = (arg1)->GetInputMethodArea();
95188     } catch (std::out_of_range& e) {
95189       {
95190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95191       };
95192     } catch (std::exception& e) {
95193       {
95194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95195       };
95196     } catch (...) {
95197       {
95198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95199       };
95200     }
95201   }
95202   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95203   return jresult;
95204 }
95205
95206
95207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95208   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95209   Dali::InputMethodOptions *arg2 = 0 ;
95210
95211   arg1 = (Dali::ImfManager *)jarg1;
95212   arg2 = (Dali::InputMethodOptions *)jarg2;
95213   if (!arg2) {
95214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95215     return ;
95216   }
95217   {
95218     try {
95219       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95220     } catch (std::out_of_range& e) {
95221       {
95222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95223       };
95224     } catch (std::exception& e) {
95225       {
95226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95227       };
95228     } catch (...) {
95229       {
95230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95231       };
95232     }
95233   }
95234 }
95235
95236
95237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95238   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95239   std::string *arg2 = 0 ;
95240
95241   arg1 = (Dali::ImfManager *)jarg1;
95242   if (!jarg2) {
95243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95244     return ;
95245   }
95246   std::string arg2_str(jarg2);
95247   arg2 = &arg2_str;
95248   {
95249     try {
95250       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95251     } catch (std::out_of_range& e) {
95252       {
95253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95254       };
95255     } catch (std::exception& e) {
95256       {
95257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95258       };
95259     } catch (...) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95262       };
95263     }
95264   }
95265
95266   //argout typemap for const std::string&
95267
95268 }
95269
95270
95271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95272   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95273   std::string *arg2 = 0 ;
95274
95275   arg1 = (Dali::ImfManager *)jarg1;
95276   if (!jarg2) {
95277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95278     return ;
95279   }
95280   std::string arg2_str(jarg2);
95281   arg2 = &arg2_str;
95282   {
95283     try {
95284       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95285     } catch (std::out_of_range& e) {
95286       {
95287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95288       };
95289     } catch (std::exception& e) {
95290       {
95291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95292       };
95293     } catch (...) {
95294       {
95295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95296       };
95297     }
95298   }
95299
95300 }
95301
95302
95303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95304   int jresult ;
95305   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95306   Dali::ImfManager::State result;
95307
95308   arg1 = (Dali::ImfManager *)jarg1;
95309   {
95310     try {
95311       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95312     } catch (std::out_of_range& e) {
95313       {
95314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95315       };
95316     } catch (std::exception& e) {
95317       {
95318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95319       };
95320     } catch (...) {
95321       {
95322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95323       };
95324     }
95325   }
95326   jresult = (int)result;
95327   return jresult;
95328 }
95329
95330
95331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95332   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95333   bool arg2 ;
95334
95335   arg1 = (Dali::ImfManager *)jarg1;
95336   arg2 = jarg2 ? true : false;
95337   {
95338     try {
95339       (arg1)->SetReturnKeyState(arg2);
95340     } catch (std::out_of_range& e) {
95341       {
95342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95343       };
95344     } catch (std::exception& e) {
95345       {
95346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95347       };
95348     } catch (...) {
95349       {
95350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95351       };
95352     }
95353   }
95354 }
95355
95356
95357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95358   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95359   bool arg2 ;
95360
95361   arg1 = (Dali::ImfManager *)jarg1;
95362   arg2 = jarg2 ? true : false;
95363   {
95364     try {
95365       (arg1)->AutoEnableInputPanel(arg2);
95366     } catch (std::out_of_range& e) {
95367       {
95368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95369       };
95370     } catch (std::exception& e) {
95371       {
95372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95373       };
95374     } catch (...) {
95375       {
95376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95377       };
95378     }
95379   }
95380 }
95381
95382
95383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95384   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95385
95386   arg1 = (Dali::ImfManager *)jarg1;
95387   {
95388     try {
95389       (arg1)->ShowInputPanel();
95390     } catch (std::out_of_range& e) {
95391       {
95392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95393       };
95394     } catch (std::exception& e) {
95395       {
95396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95397       };
95398     } catch (...) {
95399       {
95400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95401       };
95402     }
95403   }
95404 }
95405
95406
95407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95408   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95409
95410   arg1 = (Dali::ImfManager *)jarg1;
95411   {
95412     try {
95413       (arg1)->HideInputPanel();
95414     } catch (std::out_of_range& e) {
95415       {
95416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95417       };
95418     } catch (std::exception& e) {
95419       {
95420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95421       };
95422     } catch (...) {
95423       {
95424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95425       };
95426     }
95427   }
95428 }
95429
95430
95431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95432   void * jresult ;
95433   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95434   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95435
95436   arg1 = (Dali::ImfManager *)jarg1;
95437   {
95438     try {
95439       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95440     } catch (std::out_of_range& e) {
95441       {
95442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95443       };
95444     } catch (std::exception& e) {
95445       {
95446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95447       };
95448     } catch (...) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95451       };
95452     }
95453   }
95454   jresult = (void *)result;
95455   return jresult;
95456 }
95457
95458
95459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95460   void * jresult ;
95461   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95462   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95463
95464   arg1 = (Dali::ImfManager *)jarg1;
95465   {
95466     try {
95467       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95468     } catch (std::out_of_range& e) {
95469       {
95470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95471       };
95472     } catch (std::exception& e) {
95473       {
95474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95475       };
95476     } catch (...) {
95477       {
95478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95479       };
95480     }
95481   }
95482   jresult = (void *)result;
95483   return jresult;
95484 }
95485
95486
95487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95488   void * jresult ;
95489   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95490   Dali::ImfManager::StatusSignalType *result = 0 ;
95491
95492   arg1 = (Dali::ImfManager *)jarg1;
95493   {
95494     try {
95495       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95496     } catch (std::out_of_range& e) {
95497       {
95498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95499       };
95500     } catch (std::exception& e) {
95501       {
95502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95503       };
95504     } catch (...) {
95505       {
95506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95507       };
95508     }
95509   }
95510   jresult = (void *)result;
95511   return jresult;
95512 }
95513
95514
95515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95516   void * jresult ;
95517   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95518   Dali::ImfManager::VoidSignalType *result = 0 ;
95519
95520   arg1 = (Dali::ImfManager *)jarg1;
95521   {
95522     try {
95523       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95524     } catch (std::out_of_range& e) {
95525       {
95526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95527       };
95528     } catch (std::exception& e) {
95529       {
95530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95531       };
95532     } catch (...) {
95533       {
95534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95535       };
95536     }
95537   }
95538   jresult = (void *)result;
95539   return jresult;
95540 }
95541
95542
95543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95544   void * jresult ;
95545   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95546   Dali::ImfManager::VoidSignalType *result = 0 ;
95547
95548   arg1 = (Dali::ImfManager *)jarg1;
95549   {
95550     try {
95551       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95552     } catch (std::out_of_range& e) {
95553       {
95554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95555       };
95556     } catch (std::exception& e) {
95557       {
95558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95559       };
95560     } catch (...) {
95561       {
95562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95563       };
95564     }
95565   }
95566   jresult = (void *)result;
95567   return jresult;
95568 }
95569
95570
95571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95572   void * jresult ;
95573   Dali::ImfManager *result = 0 ;
95574
95575   {
95576     try {
95577       result = (Dali::ImfManager *)new Dali::ImfManager();
95578     } catch (std::out_of_range& e) {
95579       {
95580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95581       };
95582     } catch (std::exception& e) {
95583       {
95584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95585       };
95586     } catch (...) {
95587       {
95588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95589       };
95590     }
95591   }
95592   jresult = (void *)result;
95593   return jresult;
95594 }
95595
95596
95597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95598   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95599
95600   arg1 = (Dali::ImfManager *)jarg1;
95601   {
95602     try {
95603       delete arg1;
95604     } catch (std::out_of_range& e) {
95605       {
95606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95607       };
95608     } catch (std::exception& e) {
95609       {
95610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95611       };
95612     } catch (...) {
95613       {
95614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95615       };
95616     }
95617   }
95618 }
95619
95620
95621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95622   void * jresult ;
95623   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95624   Dali::ImfManager *result = 0 ;
95625
95626   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95627   {
95628     try {
95629       result = (Dali::ImfManager *)new Dali::ImfManager(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 (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95641       };
95642     }
95643   }
95644   jresult = (void *)result;
95645   return jresult;
95646 }
95647
95648
95649 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95650     return (Dali::BaseHandle *)jarg1;
95651 }
95652
95653
95654 //////////////////////////////////////////////////
95655 //from dali-swig autogeneration (from dali_wrap.cpp)
95656
95657
95658
95659
95660
95661
95662
95663
95664
95665
95666
95667
95668 #ifdef __cplusplus
95669 }
95670 #endif
95671